diff --git "a/secureCodingData.csv" "b/secureCodingData.csv"
new file mode 100644--- /dev/null
+++ "b/secureCodingData.csv"
@@ -0,0 +1,18196 @@
+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),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한
+보안약점","<html>
+<body>
+ <script>
+ const query = ""<script>alert('hello world')<""+""/script>"";
+ async function req() {
+ // 사용자가 에디터와 같은 입력 폼에 입력한 데이터를 서버에 저장
+ const response = await fetch(`/vuln/search?q=${query}`, { method: 'GET' })
+ const data = await response.text();
+ // 외부로부터 받은 데이터(HTML 코드)를 아무런 검증 없이 DOM으로 기록
+ document.write(data);
+ }
+ req();
+ </script>
+</body>
+</html>","<html>
+<body>
+ <script>
+ const query = ""<script>alert('hello world')<""+""/script>"";
+ async function req() {
+ const response = await fetch(`/vuln/search?q=${query}`, { method: 'GET' })
+ const data = await response.text();
+ // 외부로부터 받은 데이터를 이스케이프 처리 후 사용
+ document.write(decodeURI(encodeURIComponent(data)));
+ }
+ req();
+ </script>
+</body>
+</html>"
+Javascript,입력데이터 검증 및 표현,크로스사이트 스크립트(XSS),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한
+보안약점","<html>
+<body>
+ <script>
+ const query = ""<script>alert('hello world')<""+""/script>"";
+ async function req() {
+ // 사용자가 에디터와 같은 입력 폼에 입력한 데이터를 서버에 저장
+ const response = await fetch(`/vuln/search?q=${query}`, { method: 'GET' })
+ const data = await response.text();
+ // 외부로부터 받은 데이터(HTML 코드)를 아무런 검증 없이 DOM으로 기록
+ document.write(data);
+ }
+ req();
+ </script>
+</body>
+</html>","<html>
+ <head>
+ <script src=""https://cdn.rawgit.com/yahoo/xss-filters/master/dist/xss-filters.js""></script>
+ </head>
+ <body>
+ <script>
+ async function req() {
+ ...
+ // xss-filters 라이브러리를 사용해 문자열을 이스케이프 처리
+ document.write(xssFilters.inHTMLData(data));
+ }
+ req();
+ </script>
+ </body>
+</html>"
+Javascript,입력데이터 검증 및 표현,크로스사이트 스크립트(XSS),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한
+보안약점","function possibleXSS() {
+ return {
+ __html:
+ '<img
+ src=""https://upload.wikimedia.org/wikipedia/commons/a/a7/React-icon.svg“
+ onload=""alert(1)"">
+ </img>',
+ };
+ }
+ const App = ( ) => (
+ // XSS에 취약한 함수를 사용해 HTML 코드 데이터를 렌더링
+ <div dangerouslySetInnerHTML={possibleXSS()} />
+);
+ReactDOM.render(<App />, document.getElementById(""root""));","<script src=""https://cdnjs.cloudflare.com/ajax/libs/dompurify/2.4.0/purify.min.js""></script>
+... function possibleXSS() {
+ return {
+ __html:
+ // dompurify 라이브러리를 사용해 입력값을 이스케이프 처리
+ DOMPurify.sanitize('<img src=""https://upload.wikimedia.org/wikipedia/commons/
+ a/a7/React-icon.svg"" onload=""alert(1)""></img>'),
+ };
+}
+const App = ( ) => (
+ <div dangerouslySetInnerHTML={possibleXSS()} />
+);
+ReactDOM.render(<App />, document.getElementById(""root""));"
+Javascript,입력데이터 검증 및 표현,크로스사이트 스크립트(XSS),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한
+보안약점","const express = require('express');
+router.get(""/vuln/search"", (req, res) => {
+ // 사용자로부터 전달 받은 쿼리 데이터로 데이터 조회
+ const results = selectFromDB(req.query.q);
+ if (results.length === 0) {
+ // 검색 결과가 발견되지 않을 경우, ‘요청한 값’을 찾지 못했다는 메시지를 반환하는데,
+ // 이 때 정상적인 질의문이 아닌 악��� 스크립트가 포함된 데이터를 입력 받은 경우라면
+ // 클라이언트측에서 악성 스크립트가 실행될 수 있음
+ return res.send('<p>No results found for ""' + req.query.q + '""</p>');
+ } ... });","const express = require('express');
+const xssFilters = require(""xss-filters"");
+... router.get(""/patched/search"", (req, res) => {
+ const unsafeFirstname = req.query.q;
+ // xss-filters 라이브러리를 사용해 사용자 입력값을 이스케이프 처리
+ const safeFirstname = xssFilters.inHTMLData(unsafeFirstname);
+ const results = selectFromDB(safeFirstname);
+
+ if (results.length === 0) {
+ res.send(util.format(""<p>Hello %s</p>"", safeFirstname));
+ }
+... });"
+Javascript,입력데이터 검증 및 표현,운영체제 명령어 삽입,"운영체제 명령어를 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 명령어가 실행
+가능한 보안약점","const express = require('express');
+const child_process = require(""child_process"");
+router.get(""/vuln"", (req, res) => {
+ // 사용자가 입력한 명령어 인자값을 검증 없이 사용해 의도치 않은 추가 명령어 실행 가능
+ child_process.exec(""ls -l "" + req.query.path, function (err, data) {
+ return res.send(data);
+ });
+});","const express = require('express');
+const child_process = require(""child_process"");
+router.get(""/patched"", (req, res) => {
+ const inputPath = req.query.path;
+ const regPath = /^(\/[\w^]+)+\/?$/;
+ // 첫 번째 방법, 사용자 입력값 필터링 ? 리눅스 경로 지정에 필요한 문자만 허용
+ if (!inputPath.match(regPath)) {
+ return res.send('not valid path');
+ }
+ // 두 번째 방법, 사용자 입력값이 명령어의 인자로만 사용되도록 하는 함수 사용
+ child_process.execFile(
+ ""/bin/ls"", [""-l"", inputPath],
+ function (err, data) {
+ if (err) {
+ return res.send('not valid path');
+ } else {
+ return res.send(data);
+ }
+ }
+ );
+});"
+Javascript,입력데이터 검증 및 표현,위험한 형식 파일 업로드,파일의 확장자 등 파일형식에 대한 검증없이 파일 업로드를 허용하여 공격이 가능한 보안약점,"const express = require('express');
+router.post(""/vuln"", (req, res) => {
+ const file = req.files.products;
+ const fileName = file.name;
+ // 업로드 한 파일 타입 검증 부재로 악성 스크립트 파일 업로드 가능
+ file.mv(""/usr/app/temp/"" + fileName, (err) => {
+ if (err) return res.send(err);
+ res.send(""upload success"");
+ });
+}); ","const express = require('express');
+router.post(""/patched"", (req, res) => {
+ const allowedMimeTypes = [""image/png"", ""image/jpeg""];
+ const allowedSize = 5242880;
+ const file = req.files.products;
+ const fileName = file.name;
+ // 업로드 한 파일 타입 검증을 통해 악성 스크립트 파일 업로드 방지
+ if (allowedMimeTypes.indexOf(file.mimetype) < 0) {
+ res.send(""file type not allowed"");
+ } else {
+ file.mv(""/usr/app/temp/"" + fileName, (err) => {
+ if (err) return res.send(err);
+ res.send(""upload success"");
+ });
+ }
+});"
+Javascript,입력데이터 검증 및 표현,신뢰되지 않은 URL주소로 자동접속 연결,URL 링크 생성에 검증되지 않은 외부 입력값을 허용하여 악의적인 사이트로 자동 접속 가능한 보안약점,"const express = require('express');
+router.get(""/vuln"", (req, res) => {
+ const url = req.query.url;
+ // 사용자가 전달한 URL 주소를 검증 없이 그대로 리다이렉트 처리
+ res.redirect(url);
+});","const express = require('express');
+router.get(""/patched"", (req, res) => {
+ const whitelist = [""http://safe-site.com"", ""https://www.example.com""];
+ const url = req.query.url;
+
+ // 화이트리스트에 포함된 주소가 아니라면 리다이렉트 없이 에러 반환
+ if (whitelist.indexOf(url) < 0) {
+ res.send(""wrong url"");
+ } else {
+ res.redirect(url);
+ }
+});"
+Javascript,입력데이터 검증 및 표현,부적절한 XML 외부 개체 참조,임의로 조작된 XML 외부개체에 대한 적절한 검증 없이 참조를 허용하여 공격이 가능한 보안약점,"const express = require('express');
+const libxmljs = require(""libxmljs"");
+router.post(""/vuln"", (req, res) => {
+ if (req.files.products && req.files.products.mimetype == ""application/xml"") {
+ const products = libxmljs.parseXmlString(
+ req.files.products.data.toString(""utf8""),
+ // 외부 엔티티 파싱 허용 설정(미설정 시 기본값은 false)
+ { noent: true }
+ );
+ return res.send(products.get(""//foo"").text());
+ }
+ return res.send(""fail"");
+});","const express = require('express');
+const libxmljs = require(""libxmljs"");
+router.post(""/patched"", (req, res) => {
+ if (req.files.products && req.files.products.mimetype == ""application/xml"") {
+ const products = libxmljs.parseXmlString(
+ req.files.products.data.toString(""utf8""),
+ // 외부 엔티티 파싱을 허용하지 않도�� 설정
+ // 미설정 시 기본값은 false이지만, 명시적으로 선언을 해 주는 것이 좋음
+ { noent: false }
+ );
+ return res.send(products.get(""//foo"").text());
+ }
+ return res.send(""fail"");
+});"
+Javascript,입력데이터 검증 및 표현,XML 삽입,"XQuery, XPath 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이 실행 가능한 보안약점","const express = require('express');
+const xpath = require('xpath');
+const dom = require('xmldom').DOMParser;
+const xml = `<users>
+ <user>
+ <login>john</login>
+ <password>abracadabra</password>
+ <home_dir>/home/john</home_dir>
+ </user>
+ <user>
+ <login>cbc</login>
+ <password>1mgr8</password>
+ <home_dir>/home/cbc</home_dir>
+ </user>
+ </users>`;
+router.get(""/vuln"", (req, res) => {
+ const userName = req.query.userName;
+ const userPass = req.query.userPass;
+ const doc = new dom().parseFromString(xml);
+ // 조작된 입력값(/vuln?userName=john' or ''='&userPass=""' or ''='“)을 통해
+ // 패스워드 검사 로직을 우회할 수 있음
+ const badXPathExpr = ""//users/user[login/text()='"" + userName
+ + ""' and password/text() = '"" + userPass + ""']/home_dir/text()"";
+ const selected = xpath.select(badXPathExpr, doc);
+ try {
+ const userPath = selected[0].toString();
+ return res.send(`userPath = ${userPath}`);
+ } catch {
+ return res.send('not found');
+ }
+});","const express = require('express');
+const xpath = require('xpath');
+const dom = require('xmldom').DOMParser;
+const xml = `<users>
+ ...
+ </users>`;
+ router.get(""/patched"", (req, res) => {
+ const userName = req.query.userName;
+ const userPass = req.query.userPass;
+ const doc = new dom().parseFromString(xml);
+ // 인자화된 쿼리 생성
+ const goodXPathExpr = xpath.parse(""//users/user[login/text()=$userName and password/text()
+ =$userPass]/home_dir/text()"");
+ // 쿼리문에 변수값 전달 및 XML 조회
+ const selected = goodXPathExpr.select({
+ node: doc,
+ variables: { userName: userName, userPass: userPass }
+ });
+ try {
+ const userPath = selected[0].toString();
+ return res.send(`userPath = ${userPath}`);
+ } catch {
+ return res.send('not found');
+ }
+});"
+Javascript,입력데이터 검증 및 표현,LDAP 삽입,LDAP 명령문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 명령어가 실행 가능한 보안약점,"const express = require('express');
+const ldap = require('ldapjs');
+const config = {
+ url: 'ldap://ldap.forumsys.com',
+ base: 'dc=example,dc=com',
+ dn: 'cn=read-only-admin,dc=example,dc=com',
+ secret: 'd0accf0ac0dfb0d0fd...',
+};
+async function searchLDAP (search) {
+const opts = {
+ filter: `(&(objectClass=${search}))`,
+ attributes: ['sn', 'cn', 'mail', 'telephonenumber', 'uid'],
+ scope: 'sub',
+ };
+ const users = [];
+ const client = ldap.createClient({ url: config.url });
+ return new Promise((resolve, reject) => {
+ client.bind(config.dn, config.password, (err) => {
+ if (err) {
+ console.log('LDAP bind error - ', err);
+ } else {
+ client.search(config.base, opts, (err, res) => {
+ res.on('searchEntry', (entry) => {
+ users.push(entry.object);
+ });
+ ...
+ res.on('end', (result) => {
+ console.log('status: ' + result.status);
+ resolve(users);
+ });
+ });
+ }
+ });
+ });
+}
+router.get(""/vuln"", async (req, res) => {
+ // 사용자의 입력을 그대로 LDAP 질의문으로 사용해 권한 상승 등의 공격에 노출
+ const search = req.query.search;
+ const result = await searchLDAP(search);
+ return res.send(result);
+});","const express = require('express');
+const ldap = require('ldapjs');
+const parseFilter = require('ldapjs').parseFilter;
+const config = {
+ url: 'ldap://ldap.forumsys.com',
+ base: 'dc=example,dc=com',
+ dn: 'cn=read-only-admin,dc=example,dc=com',
+ secret: 'd0accf0ac0dfb0d0fd...',
+};
+async function searchLDAP (search) {
+const opts = {
+ filter: `(&(objectClass=${search}))`,
+ attributes: ['sn', 'cn', 'mail', 'telephonenumber', 'uid'],
+ scope: 'sub',
+ };
+ const users = [];
+ const client = ldap.createClient({ url: config.url });
+ return new Promise((resolve, reject) => {
+ client.bind(config.dn, config.password, (err) => {
+ if (err) {
+ console.log('LDAP bind error - ', err);
+ } else {
+ client.search(config.base, opts, (err, res) => {
+ res.on('searchEntry', (entry) => {
+ users.push(entry.object);
+ });
+ ...
+ res.on('end', (result) => {
+ console.log('status: ' + result.status);
+ resolve(users);
+ });
+ });
+ }
+ });
+ });
+}
+router.get(""/patched"", async (req, res) => {
+ let search;
+ // 사용자의 입력에 필터링을 적용해 공격에 사용될 수 있는 문자 발견 시
+ // 사용자에게 잘못된 요청값임을 알리고, 질의문을 요청하지 않음
+ try {
+ search = parseFilter(req.query.search);
+ } catch {
+ return res.send('잘못된 요청값입니다.');
+ }
+ const result = await searchLDAP(search);
+ return res.send(result);
+});"
+Javascript,입력데이터 검증 및 표현,크로스사이트 요청 위조(CSRF),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게
+공격자가 의도한 행위가 실행 가능한 보안약점","<html>
+... <body>
+ <form method='post' action='/api/vuln'>
+ <!-- CSRF 토큰 없이 폼 데이터를 서버에 전달 -->
+ <fieldset>
+ <legend>Your Profile:</legend>
+ <label for='username'> Name:</label>
+ <input name='username' class='username' type='text'> <br><br>
+ <label for='email' > Email:</label>
+ <input name='email' class='useremail' type='email'> <br><br>
+ <button type='submit'>UPDATE</button>
+ </fieldset>
+ </form>
+</body>
+</html>"," <form method='post' action='/api/vuln'>
+ <!-- 서버로부터 제공 받은 CSRF 토큰을 폼 데이터에 hidden 값으로 포함해 전달 -->
+ <input type='hidden' name='_csrf' value='<%= csrfToken %>'>
+ <fieldset>
+ <legend>Your Profile:</legend>
+ <label for='username'> Name:</label>
+ <input name='username' class='username' type='text'> <br><br>
+ <label for='email' > Email:</label>
+ <input name='email' class='useremail' type='email'> <br><br>
+ <button type='submit'>UPDATE</button>
+ </fieldset>
+ </form>"
+Javascript,입력데이터 검증 및 표현,크로스사이트 요청 위조(CSRF),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게
+공격자가 의도한 행위가 실행 가능한 보안약점","const express = require('express');
+router.post(""/api/vuln"", (req, res) => {
+ const userName = req.body.username;
+ const userEmail = req.body.useremail;
+ // 사용자 업데이트 요청이 정상 사용자로부터 온 것이라고 간주하고,
+ // 사용자로부터 받은 값을 그대로 내부 함수에 전달
+ if (update_user(userName, userEmail)) {
+ return res.send('update completed');
+ } else {
+ return res.send('update error');
+ }
+});","const csrf = require('csurf');
+const express = require('express');
+const session = require(""express-session"");
+const app = express();
+// 토큰을 쿠키가 아닌 세션에 저장
+app.use(session({
+ secret: process.env.COOKIE_SECRET,
+ cookie: { path: '/', secure: true, httpOnly: true, sameSite: 'strict' },
+ saveUninitialized: false,
+ resave: false
+}));
+// CSRF 토큰 이름 앞에 __Host- 접두어 추가
+const csrfProtection = csrf({
+ key: '__Host-token',
+});
+// 클라이언트측 프레임워크(ReactJS)를 위한 토큰 값 제공
+router.get(""/getCSRFToken"", csrfProtection, (req, res) => {
+ res.json({ csrfToken: req.csrfToken() });
+});
+// 템플릿 페이지를위한 토큰 값 제공
+router.get(""/page"", csrfProtection, (req, res) => {
+ res.render('csrf', { csrfToken: req.csrfToken() });
+});
+// 라우터 데이터 처리 전 클라이언트의 csrf 토큰을 검사
+router.post(""/api/patched"", csrfProtection, (req, res) => {
+ const userName = req.body.username;
+ const userEmail = req.body.useremail;
+ if (update_user(userName, userEmail)) {
+ return res.send('update completed');
+ } else {
+ return res.send('update error');
+ }
+});"
+Javascript,입력데이터 검증 및 표현,크로스사이트 요청 위조(CSRF),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게
+공격자가 의도한 행위가 실행 가능한 보안약점","클라이언트측에서 렌더링을 처리하는 ReactJS의 경우 서버 기능 호출 전 서버로부터 토큰을 받아와 요청 헤더
+내에 삽입해야 한다","const App = () => {
+ const getData = async () => {
+ // 서버에 기능 호출 전 먼저 CSRF 토큰을 받아와 헤더에 저장
+ const response = await axios.get('getCSRFToken');
+ axios.defaults.headers.post['X-CSRF-Token'] = response.data.csrfToken;
+ // CSRF 토큰이 설정된 상태에서 서버 기능 호출
+ const res = await axios.post('api/patched', {
+ username: ‘hello_user’,
+ useremail: ‘test@email.com’,
+ });
+ document.write(res.data);
+ };
+ React.useEffect(() => { getData(); }, []);
+ return <div>react-test</div>;
+};
+ReactDOM.render(<App />, document.getElementById(""root""));"
+Javascript,입력데이터 검증 및 표현,서버사이드 요청 위조,"서버 간 처리되는 요청에 검증되지 않은 외부 입력값을 허용하여 공격자가 의도한 서버로 전송
+하거나 변조하는 보안약점","const request = require('request');
+const express = require('express');
+router.get(""/vuln"", async (req, res) => {
+ const url = req.query.url;
+ // 사용자가 입력한 주소를 검증하지 않고 HTTP 요청을 보낸 후
+ // 그 응답을 그대로 사용자에게 전달
+ await request(url, (err, response) => {
+ const resData = response.body;
+ return res.send(resData);
+ });
+});","const request = require('request');
+const express = require('express');
+router.get(""/patched"", async (req, res) => {
+ const url = req.query.url;
+ const whiteList = [ 'www.example.com', 'www.safe.com'];
+ // 사용자가 입력한 URL을 화이트리스트로 검증한 후 그 결과를 반환하여
+ // 검증되지 않은 주소로 요청을 보내지 않도록 제한
+ if (whiteList.includes(url)) {
+ await request(url, (err, response) => {
+ const resData = response.body;
+ return res.send(resData);
+ });
+ } else {
+ return res.send('잘못된 요청입니다');
+ }
+});"
+Javascript,입력데이터 검증 및 표현,보안기능 결정에 사용되는 부적절한 입력값,"보안기능(인증, 권한부여 등) 결정에 검증되지 않은 외부 입력값을 허용하여 보안기능을 우회하는
+보안약점","const express = require('express');
+router.get(""/admin"", (req, res) => {
+ // 쿠키에서 권한 정보를 가져옴
+ const role = req.cookies.role;
+ if (role === ""admin"") {
+ // 쿠키에서 가져온 권한 정보로 관리자 페이지 접속 처리
+ return res.render(‘admin’. { title: ’관리자 페이지‘ } ));
+ } else {
+ return res.send(""사용 권한이 없습니다."");
+ }
+});","const express = require('express');
+const session = require(""express-session"");
+app.use(session({
+ secret: 'test',
+ resave: true,
+ saveUninitialized: true,
+ store: new MemoryStore({checkPeriod: 60 * 60 * 1000})
+}));
+router.get(""/patched"", (req, res) => {
+ // 세션에서 권한 정보를 가져옴
+ const role = req.session.role;
+ if (role === ""admin"") {
+ // 세션에서 가져온 권한 정보로 관리자 페이지 접속 처리
+ return res.render(‘admin’. { title: ’관리자 페이지‘ } ));
+ } else {
+ return res.send(""사용 권한이 없습니다."");
+ }
+});"
+Javascript,보안기능,적절한 인증 없는 중요 기능 허용,"중요정보(금융정보, 개인정보, 인증정보 등)를 적절한 인증없이 열람(또는 변경) 가능한
+보안약점","const express = require('express');
+const crypto = require(""crypto"");
+router.post(""/vuln"", (req, res) => {
+ const newPassword = req.body.newPassword;
+ const user = req.session.userid;
+ const hs = crypto.createHash(“sha256”)
+ const newHashPassword = hs.update(newPassword).digest(""base64"");
+ // 현재 패스워드와 일치 여부를 확인하지 않고 업데이트
+ updatePasswordFromDB(user, newHashPassword);
+ return res.send({message: ""패스워드가 변경되었습니다."", userId, password, hashPassword});
+});","const express = require('express');
+const crypto = require(""crypto"");
+router.post(""/patched"", (req, res) => {
+ const newPassword = req.body.newPassword;
+ const user = req.session.userid;
+ const oldPassword = getPasswordFromDB(user);
+ const salt = crypto.randomBytes(16).toString('hex');
+ const hs = crypto.createHash(""sha256“)
+ const currentPassword = req.body.currentPassword;
+ const currentHashPassword = hs.update(currentPassword + salt).digest(""base64"");
+
+ // 현재 패스워드 확인 후 사용자 정보 업데이트
+ if (currentHashPassword === oldPassword) {
+ const newHashPassword = hs.update(newPassword + salt).digest(""base64"");
+ updatePasswordFromDB(user, newHashPassword);
+ return res.send({ message: ""패스워드가 변경되었습니다."" });
+ } else {
+ return res.send({ message: ""패스워드가 일치하지 않습니다."" });
+ }
+});"
+Javascript,보안기능,부적절한 인가,중요자원에 접근할 때 적절한 제어가 없어 비인가자의 접근이 가능한 보안약점,"const express = require('express');
+function deleteContentFromDB(contentId) {
+... }
+router.delete(""/vuln"", (req, res) => {
+ const contentId = req.body.contentId;
+ // 작업 요청을 하는 사용자의 권한 확인 없이 삭제 작업 수행
+ deleteContentFromDB(contentId);
+ return res.send(""삭제가 완료되었습니다."");
+});","const express = require('express');
+function deleteContentFromDB(contentId) { ... }
+router.delete(""/patched"", (req, res) => {
+ const contentId = req.body.contentId;
+ const role = req.session.role;
+ // 삭제 기능을 수행할 권한이 있는 경우에만 삭제 작업 수행
+ if (role === ""admin"") {
+ deleteContentFromDB(contentId);
+ return res.send(""삭제가 완료되었습니다."");
+ } else {
+ return res.send(""권한이 없습니다."");
+ }
+});"
+Javascript,보안기능,중요한 자원에 대한 잘못된 권한 설정,중요자원에 적절한 접근 권한을 부여하지 않아 중요정보가 노출·수정 가능한 보안약점,"const fs = require(""fs"");
+function writeFile() {
+ // 모든 사용자가 읽기, 쓰기, 실행 권한을 가지게 됨
+ fs.chmodSync(""/root/system_config"", 0o777);
+ fs.open(""/root/system_config"", ""w"", function(err,fd) {
+ if (err) throw err;
+ });
+ fs.writeFile(""/root/system_config"", ""your config is broken"", function(err) {
+ if (err) throw err;
+ console.log('write end');
+ });
+}","const fs = require(""fs"");
+function writeFile() {
+ // 소유자 이외에는 권한을 가지지 않음
+ fs.chmodSync(""/root/system_config"", 0o700);
+ fs.open(""/root/system_config"", ""w"", function(err,fd) {
+ if (err) throw err;
+ });
+ fs.writeFile(""/root/system_config"", ""your config is broken"", function(err) {
+ if (err) throw err;
+ console.log('write end');
+ })
+}"
+Javascript,보안기능,취약한 암호화 알고리즘 사용,"중요정보 (금융정보, 개인정보, 인증정보 등)의 기밀성을 보장할 수 없는 취약한 암호화 알
+고리즘을 사용하여 정보가 노출 가능한 보안약점","const crypto = require(""crypto"");
+function getEncText(plainText, key) {
+ // 취약한 알고리즘인 DES를 사용하여 안전하지 않음
+ const cipherDes = crypto.createCipheriv('des-ecb', key, '');
+ const encryptedData = cipherDes.update(plainText, 'utf8', 'base64');
+ const finalEnctypedData = cipherDes.final('base64');
+ return encryptedData + finalEnctypedData;
+}","const crypto = require(""crypto"");
+function getEncText(plainText, key, iv) {
+ // 권장 알고리즘인 AES를 사용하여 안전함
+ const cipherAes = crypto.createCipheriv('aes-256-cbc', key, iv);
+ const encryptedData = cipherAes.update(plainText, 'utf8', 'base64');
+ const finalEnctypedData = cipherAes.final('base64');
+ return encryptedData + finalEnctypedData;
+}"
+Javascript,보안기능,취약한 암호화 알고리즘 사용,"중요정보 (금융정보, 개인정보, 인증정보 등)의 기밀성을 보장할 수 없는 취약한 암호화 알
+고리즘을 사용하여 정보가 노출 가능한 보안약점","const crypto = require(""crypto"");
+function makeMd5(plainText) {
+ // 취약한 md5 해쉬함수 사용
+ const hashText = crypto.createHash('md5').update(plainText).digest(""hex"");
+ return hashText;
+}","const crypto = require(""crypto"");
+function makeSha256(plainText) {
+ const salt = crypto.randomBytes(16).toString('hex');
+ // 안전한 sha-256 해쉬함수 사용
+ const hashText = crypto.createHash('sha256').update(plainText + salt).digest(""hex"");
+ return hashText;
+}"
+Javascript,보안기능,암호화되지 않은 중요정보,"중요정보(패스워드, 개인정보 등) 전송 시 암호화 또는 안전한 통신채널을 이용하지 않거나, 저장 시 암호화 하지 않아 정보가 노출 가능한 보안약점","function updatePass(dbconn, password, user_id) {
+ // 암호화되지 않은 비밀번호를 DB에 저장하는 경우 위험함
+ const sql = 'UPDATE user SET password=? WHERE user_id=?';
+ const params = [password, user_id];
+ dbconn.query(sql, params, function(err, rows, fields){
+ if (err) console.log(err);
+ })
+}","const crypto = require(""crypto"");
+function updatePass(dbconn, password, user_id, salt) {
+ // 단방향 암호화를 이용하여 비밀번호를 암호화
+ const sql = 'UPDATE user SET password=? WHERE user_id=?';
+ const hashPw = crypto.createHash('sha256').update(password + salt, 'utf-8').digest('hex');
+ const params = [hashPw, user_id];
+ dbconn.query(sql, params, function(err, rows, fields){
+ if (err) console.log(err);
+ })
+}"
+Javascript,보안기능,암호화되지 않은 중요정보,"중요정보(패스워드, 개인정보 등) 전송 시 암호화 또는 안전한 통신채널을 이용하지 않거나, 저장 시 암호화 하지 않아 정보가 노출 가능한 보안약점","const { io } = require(""socket.io-client"");
+const socket = io(""http://localhost:3000"");
+function sendPassword(password) {
+ // 패스워드를 암호화 하지 않고 전송하여 안전하지 않음
+ socket.emit(""password"", password);
+}
+socket.on(""password"", function(data) {
+ if (data === 'success') {
+ console.log(""\nSuccess to send a message to a server \n"")
+ }
+});","const { io } = require(""socket.io-client"");
+const crypto = require(""crypto"");
+const socket = io(""http://localhost:3000"");
+const PASSWORD = getPassword();
+function aesEncrypt(plainText) {
+ const key = getCryptKey();
+ const iv = getCryptIV();
+ const cipherAes = crypto.createCipheriv('aes-256-cbc', key, iv);
+ const encryptedData = cipherAes.update(plainText, 'utf8', 'base64');
+ const finalEncryptedData = cipherAes.final('base64');
+ return encryptedData + finalEncryptedData;
+}
+function sendPassword(password) {
+ // 패스워드 등 중요정보는 암호화하여 전송하는 것이 안전함
+ const encPassword = aesEncrypt(password);
+ socket.emit(""password"", encPassword);
+}
+socket.on(""password"", function(data) {
+ if (data === 'success') {
+ console.log(""\nSuccess to send a message to a server \n"")
+ }
+});"
+Javascript,보안기능,하드코드된 중요정보,"소스코드에 중요정보(패스워드, 암호화키 등)를 직접 코딩하여 소스코드 유출 시 중요정보가 노출되고 주기적 변경이 어려운 보안약점","const express = require('express');
+const mysql = require(""mysql"");
+const crypto = require(""crypto"");
+const dbQuery = ""SELECT email, name FROM user WHERE name = 'test'"";
+router.get(""/vuln"", (req, res) => {
+ // 데이터베이스 연결에 필요한 인증 정보가 평문으로 하드코딩되어 있음
+
+const connection = mysql.createConnection({
+ host: 'localhost',
+ user: 'root',
+ password: 'root1234',
+ database: 'javascript',
+ port: 3306,
+ });
+ connection.query(
+ dbQuery, (err, result) => {
+ if (err) return res.send(err);
+ return res.send(result);
+ })
+});","const express = require('express');
+const mysql = require(""mysql"");
+const crypto = require(""crypto"");
+const dbQuery = ""SELECT email, name FROM user WHERE name = 'test'"";
+const key = getCryptKey(); // 32bytes
+const iv = getCryptIV(); // 16bytes
+router.get(""/patched"", (req, res) => {
+ // 설정파일에 암호화 되어 있는 user, password 정보를 가져와 복호화 한 후 사용
+ const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
+ const user = decipher.update(process.env.USER, 'base64', 'utf8') + decipher.final('utf8');
+ const decipher2 = crypto.createDecipheriv('aes-256-cbc', key, iv);
+ const password = decipher2.update(process.env.PASSWORD, 'base64', 'utf8') + decipher2.final
+('utf8');
+ // DB 연결 정보도 설정파일에서 가져와 사용
+ const connection = mysql.createConnection({
+ host: process.env.DB_HOST,
+ user: user,
+ password: password,
+ database: process.env.DB_NAME,
+ port: process.env.PORT,
+ });"
+Javascript,보안기능,충분하지 않은 키 길이 사용,암호화 등에 사용되는 키의 길이가 충분하지 않아 데이터의 기밀성·무결성을 보장할 수 없는 보안약점,"const crypto = require(""crypto"");
+function vulnMakeRsaKeyPair() {
+ // RSA키 길이를 1024 비트로 설정하는 경우 안전하지 않음
+ const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa',
+ {
+ modulusLength: 1024,
+ publicKeyEncoding: { type: ""spki"", format: 'pem' },
+ privateKeyEncoding: { type: ""pkcs8"", format: 'pem' }
+ });
+ return { PRIVATE: publicKey, PUBLIC: privateKey }
+}
+function vulnMakeEcc() {
+ // ECC 키 길이가 224비트 이하이면 안전하지 않음
+ const { publicKey, privateKey } = crypto.generateKeyPairSync('ec', {
+ namedCurve: 'secp192k1',
+ publicKeyEncoding: { type: 'spki', format: 'der' },
+ privateKeyEncoding: { type: 'pkcs8', format: 'der' }
+ });
+ return { PRIVATE: publicKey.toString('hex'), PUBLIC: privateKey.toString('hex') }
+}","const crypto = require(""crypto"");
+function vulnMakeRsaKeyPair() {
+ // RSA키 길이를 2048 비트로 설정해 안전함
+ const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa',
+ {
+ modulusLength: 2048,
+ publicKeyEncoding: { type: ""spki"", format: 'pem' },
+ privateKeyEncoding: { type: ""pkcs8"", format: 'pem' }
+ });
+ return { PRIVATE: publicKey, PUBLIC: privateKey }
+}
+function vulnMakeEcc() {
+ // ECC 키 길이를 256 비트로 설정해 안전함
+ const { publicKey, privateKey } = crypto.generateKeyPairSync('ec', {
+ namedCurve: 'secp256k1',
+ publicKeyEncoding: { type: 'spki', format: 'der' },
+ privateKeyEncoding: { type: 'pkcs8', format: 'der' }
+ });
+ return { PRIVATE: publicKey.toString('hex'), PUBLIC: privateKey.toString('hex') }
+}"
+Javascript,보안기능,적절하지 않은 난수 값 사용,"사용한 난수가 예측 가능하여, 공격자가 다음 난수를 예상해서 시스템을 공격 가능한 보안
+약점","function getOtpNumber() {
+ let randomStr = '';
+ // Math.random 라이브러리는 보안기능에 사용하면 위험함
+ for (let i = 0; i < 6; i++) {
+ randomStr += String(Math.floor(Math.random() * 10))
+ }
+ return randomStr;
+}","const crypto = require(""crypto"");
+function getOtpNumber() {
+ // 보안기능에 적합한 난수 생성용 crypto 라이브러리 사용
+ const array = new Uint32Array(1);
+ // 브라우저에서는 crypto 대신에 window.crypto를 사용
+ const randomStr = crypto.getRandomValues(array);
+ let result;
+ for (let i = 0; i < randomStr.length; i++) {
+ result = array[i];
+ }
+ return String(result).substring(0, 6);
+}"
+Javascript,보안기능,취약한 패스워드 허용,"패스워드 조합규칙(영문, 숫자, 특수문자 등) 미흡 및 길이가 충분하지 않아 패스워드가
+노출 가능한 보안약점","const express = require('express');
+const mysql = require(""mysql"");
+const connection = mysql.createConnection( ... );
+ router.post(""/vuln"", (req, res) => {
+ const con = connection;
+ const { email, password, name } = req.body;
+ // 패스워드 생성 규칙 검증 없이 회원 가입 처리
+ con.query(
+ ""INSERT INTO user (email, password, name) VALUES (?, ?, ?)"",
+ [email, password, name],
+ (err, result) => {
+ if (err) return res.send(err);
+ return res.send(""회원가입 성공"");
+ });
+});","const express = require('express');
+const mysql = require(""mysql"");
+const connection = mysql.createConnection(...);
+ router.post(""/patched"", (req, res) => {
+ const con = connection;
+ const { email, password, name } = req.body;
+ function checkPassword(password) {
+ // 2종 이상 문자로 구성된 8자리 이상 비밀번호 검사 정규식
+ const pt1 = /^(?=.*[A-Z])(?=.*[a-z])[A-Za-z\d!@#$%^&*]{8,}$/;
+ const pt2 = /^(?=.*[A-Z])(?=.*\d)[A-Za-z\d!@#$%^&*]{8,}$/;
+ const pt3 = /^(?=.*[A-Z])(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$/;
+ const pt4 = /^(?=.*[a-z])(?=.*\d)[A-Za-z\d!@#$%^&*]{8,}$/;
+ const pt5 = /^(?=.*[a-z])(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$/;
+ const pt6 = /^(?=.*\d)(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$/;
+ // 문자 구성 상관없이 10자리 이상 비밀번호 검사 정규식
+ const pt7 = /^[A-Za-z\d!@#$%^&*]{10,}$/;
+ for (let pt of [pt1, pt2, pt3, pt4, pt5, pt6, pt7]) {
+ console.log(pt.test(password));
+ if (pt.test(password)) return true;
+ }
+ return false;
+ }
+ if (checkPassword(password)) {
+ con.query(
+ ""INSERT INTO user (email, password, name) VALUES (?, ?, ?)"",
+ [email, password, name],
+ (err, result) => {
+ if (err) return res.send(err);
+ return res.send(""회원가입 성공"");
+ }
+ );
+ } else {
+ return res.send(""비밀번호는 영문 대문자, 소문자, 숫자, 특수문자 조합 중 2가지 이상 8자리이거나
+ 문자 구성 상관없이 10자리 이상이어야 합니다."");
+ }
+});"
+Javascript,보안기능,부적절한 전자서명 확인,"프로그램, 라이브러리, 코드의 전자서명에 대한 유효성 검증이 적절하지 않아 공격자의
+악의적인 코드가 실행 가능한 보안약점","const express = require('express');
+const crypto = require(""crypto"");
+const fs = require(‘fs’);
+router.post(""/vuln"", (req, res) => {
+ // 클라이언트로부터 전달받은 데이터(전자서명을 수신 처리 하지 않음)
+ const { encrypted_msg } = req.body;
+ let secret_key;
+ fs.readFile(‘/keys/secret_key.out’, ‘utf8’, (err, data) => {
+ if (err) {
+ console.error(err);
+ return;
+ }
+ secret_key = data;
+ }
+ // 대칭키로 클라이언트가 전달한 코드 복호화
+ // (decrypt_with_symmetric_key 함수는 임의의 함수명으로 세부적인 복호화 과정은 생략함)
+ const decrypted = decrypt_with_symmetric_key(encrypted_msg, secret_key);
+ // 클라이언트로부터 전달 받은 코드 실행
+ eval(decrypted);
+ res.send('요청한 코드를 실행했습니다');
+});","// 전자서명 검증에 사용한 코드는 의존한 패키지 및 송신측 언어에 따라
+// 달라질 수 있으며, 서명을 제공한 서버의 공개키로 복호화한 전자서명과 원본 데이터 해쉬값의
+// 일치 여부를 검사하는 코드를 포함
+const express = require('express');
+const crypto = require(""crypto"");
+router.post(""/patched"", (req, res) => {
+
+ const { encrypted_msg, encrypted_sig, client_pub_key } = req.body;
+ let secret_key;
+ fs.readFile(‘/keys/secret_key.out’, ‘utf8’, (err, data) => {
+ if (err) {
+ console.error(err);
+ return;
+ }
+ secret_key = data;
+ }
+ // 대칭키로 클라이언트 데이터 및 전자서명 복호화
+ const decrypted_msg = decrypt_with_symmetric_key(encrypted_msg);
+ const decrypted_sig = decrypt_with_symmetric_key(encrypted_sig);
+ // 전자서명 검증에 통과한 경우에만 데이터 실행
+ if (verify_digit_signature(decrypted_msg, decrypted_sig, clint_pub_key)) {
+ eval(decrypted_msg);
+ res.send('요청한 코드를 실행했습니다');
+ } else {
+ res.send('[!] 에러 - 서명이 올바르지 않습니다.');
+ }
+});"
+Javascript,보안기능,"부적절한 인증서
+유효성 검증",인증서에 대한 유효성 검증이 적절하지 않아 발생하는 보안약점,"const https = require('https');
+const getServer = () => {
+
+ const options = {
+ hostname: ""dangerous.website"",
+ port: 443,
+ method: ""GET"",
+ path: ""/"",
+ // 유효하지 않은 인증서를 가지고 있어도 무시하는 옵션으로 안전하지 않음
+ rejectUnauthorized: false
+ };
+ https.request(
+ options, (response) => {
+ console.log('response - ', response.statusCode);
+ }
+ );
+});","const express = require('express');
+const https = require('https');
+const getServer = () => {
+
+ const options = {
+ hostname: ""dangerous.website"",
+ port: 443,
+ method: ""GET"",
+ path: ""/"",
+ // 유효하지 않은 인증서 발견 시 예외 발생
+ rejectUnauthorized: true
+ };
+ const hreq = https.request(
+ options, (response) => {
+ console.log('response - ', response.statusCode);
+ }
+ );
+ hreq.on('error', (e) => {
+ console.error('에러발생 - ', e);
+ });
+});"
+Javascript,보안기능,사용자 하드디스크에 저장되는 쿠키를 통한 정보노출,"쿠키(세션 ID, 사용자 권한정보 등 중요정보)를 사용자 하드디스크에 저장하여 중요정보가 노출 가능한 보안약점","const express = require('express');
+router.get(""/vuln"", (req, res) => {
+ // 쿠키의 만료 시간을 1년으로 과도하게 길게 설정하고 있어 안전하지 않다
+ res.cookie('rememberme', '1', {
+ expires: new Date(Date.now() + 365*24*60*60*1000)
+ });
+ return res.send(""쿠키 발급 완료"");
+});","const express = require('express');
+router.get(""/patched"", (req, res) => {
+ // 쿠키의 만료 시간을 적절하게 부여하고 secure 옵션을 활성화
+ res.cookie('rememberme', '1', {
+ expires: new Date(Date.now() + 60*60*1000),
+ secure: true,
+ httpOnly: true
+ });
+ return res.send(""쿠키 발급 완료"");
+});"
+Javascript,보안기능,"주석문 안에 포함된
+시스템 주요정보",소스코드 주석문에 인증정보 등 시스템 주요정보가 포함되어 소스코드 노출 시 주요정보도 노출 가능한 보안약점,"const express = require('express');
+router.post(""/vuln"", (req, res) => {
+ // 주석문에 포함된 중요 시스템의 인증 정보
+ // id = admin
+ // password = 1234
+ const result = login(req.body.id, req.body.password);
+ return res.send(result);
+});","const express = require('express');
+router.post(""/vuln"", (req, res) => {
+ // 주석문에 포함된 민감한 정보는 삭제
+ const result = login(req.body.id, req.body.password);
+ return res.send(result);
+});"
+Javascript,보안기능,"솔트 없이 일방향
+해쉬 함수 사용","솔트를 사용하지 않고 생성된 해쉬 값으로부터 공격자가 미리 계산된 레인보우 테이블을
+이용하여 해쉬 적용 이전 원본 정보를 복원가능한 보안약점","const crypto = require(""crypto"");
+function getHashFromPwd(pw) {
+ // salt가 없이 생성된 해쉬값은 강도가 약해 취약
+ const hash = crypto.createHash('sha256').update(pw).digest('hex');
+ return hash;
+}","const crypto = require(""crypto"");
+function getHashFromPwd(pw) {
+ // 솔트 값을 사용하면 길이가 짧은 패스워드로도 고강도의 해쉬를 생성할 수 있음
+ // 솔트 값은 사용자별로 유일하게 생성해야 하며, 패스워드와 함께 DB에 저장해야 함
+ const salt = crypto.randomBytes(16).toString('hex');
+ const hash = crypto.createHash('sha256').update(pw + salt).digest('hex');
+ return { hash, salt };
+}"
+Javascript,보안기능,"무결성 검사 없는 코드
+다운로드","소스코드 또는 실행파일을 무결성 검사 없이 다운로드 받아 실행하는 경우, 공격자의 악의
+적인 코드가 실행 가능한 보안약점","const express = require('express');
+const fs = require(""fs"");
+const http = require(""http"");
+router.get(""/vuln"", (req, res) => {
+ // 신뢰할 수 없는 사이트에서 코드를 다운로드
+ const url = ""https://www.somewhere.com/storage/code.js"";
+ // 원격 코드 다운로드
+ http.get(url, (res) => {
+ const path = ""./temp/sample1.js""
+ const writeStream = fs.createWriteStream(path);
+ res.pipe(writeStream);
+ writeStream.on(""finish"", () => {
+ writeStream.close();
+ });
+ });
+ // 무결성 검증 없이 파일 사용
+ fs.readFile(""./temp/sample1.js"", ""utf8"", function (err, buf) {
+ res.end(buf);
+ })
+});","const express = require('express');
+const fs = require(""fs"");
+const http = require(""http"");
+const crypto = require(""crypto"");
+router.get(""/patched"", async (req, res) => {
+ const url = ""https://www.somewhere.com/storage/code.js"";
+ const codeHash = req.body.codeHash;
+ http.get(url, (res) => {
+ const path = ""./temp/sample1.js""
+ const writeStream = fs.createWriteStream(path);
+ res.pipe(writeStream);
+ writeStream.on(""finish"", () => {
+ writeStream.close();
+ });
+ });
+ const hash = crypto.createHash('sha256');
+ const input = fs.createReadStream(""./temp/sample1.js"");
+ let promise = new Promise ((resolve, reject) => {
+ input.on(""readable"", () => {
+ const data = input.read();
+ if (data) { hash.update(data); }
+ else { resolve(); }
+ })
+ });
+ await promise;
+ const fileHash = hash.digest('hex');
+ # 무결성 검증에 통과할 경우에만 파일 사용
+ if (fileHash === codeHash) {
+ fs.readFile(""./temp/sample1.js"", ""utf8"", function (err, buf) {
+ res.end(buf);
+ })
+ } else {
+ return res.send(""파일이 손상되었습니다."")
+ }
+});"
+Javascript,보안기능,"반복된 인증시도
+제한 기능 부재","인증 시도 수를 제한하지 않아 공격자가 반복적으로 임의 값을 입력하여 계정 권한을 획득
+가능한 보안약점","const express = require('express');
+const crypto = require('crypto');
+router.post(""/vuln"", (req, res) => {
+ const id = req.body.id;
+ const password = req.body.password;
+ const hashPassword = crypto.createHash(""sha512"").update(password).digest(""base64"");
+ const currentHashPassword = getUserPasswordFromDB(id);
+
+ // 인증 시도에 따른 제한이 없어 반복적인 인증 시도가 가능
+ if (hashPassword === currentHashPassword) {
+ return res.send(""login success"");
+ } else {
+ return res.send(""login fail"")
+ }
+});","const express = require('express');
+const crypto = require('crypto');
+const LOGIN_TRY_LIMIT = 5;
+router.post(""/patched"", (req, res) => {
+ const id = req.body.id;
+ const password = req.body.password;
+ // 로그인 실패기록 가져오기
+ const loginFailCount = getUserLoginFailCount(id);
+ // 로그인 실패횟수 초과로 인해 잠금된 계정에 대한 인증 시도 제한
+ if (loginFailCount >= LOGIN_TRY_LIMIT) {
+ return res.send(""account lock(too many failed)"")
+ }
+// 해시 생성시 솔트를 사용하는 것이 안전하나, 코드의 복잡성을 피하기 위해 생략
+ const hashPassword = crypto.createHash(""sha512"").update(password).digest(""base64"");
+ const currentHashPassword = getUserPasswordFromDB(id);
+ if (hashPassword === currentHashPassword) {
+ deleteUserLoginFailCount(id);
+ return res.send(""login success"");
+ } else {
+ updateUserLoginFailCount(id);
+ return res.send(""login fail"")
+ }
+});"
+Javascript,시간 및 상태,"종료되지 않는 반복문
+또는 재귀함수",종료조건 없는 제어문 사용으로 반복문 또는 재귀함수가 무한히 반복되어 발생할 수 있는 보안약점,"function factorial(x) {
+ # 재귀함수 탈출조건을 설정하지 않아 동작 중 에러 발생
+ return x * factorial(x - 1);
+});","function factorial(x) {
+ # 재귀함수 사용 시에는 탈출 조건을 명시해야 한다
+ if ( x === 0 ) {
+ return;
+ }
+ else {
+ return x * factorial(x - 1);
+ }
+}"
+Javascript,에러처리,오류 메시지 정보노출,"오류메시지나 스택정보에 시스템 내부구조가 포함되어 민감한 정보, 디버깅 정보가 노출 가능한 보안약점","const express = require('express');
+const fs = require(""fs"");
+router.get(""/vuln"", (req, res) => {
+ const filePath = ""./file/secret/password"";
+ fs.readFile(filePath, (err, data) => {
+ if (err) {
+ // 서버 내부에서 발생한 에러 메시지를 그대로 사용자에 전달해 주요 정보 노출 위험
+ return res.status(500).send(err);
+ } else {
+ return res.send(data);
+ }
+ })
+});","const express = require('express');
+const fs = require(""fs"");
+router.get(""/vuln"", (req, res) => {
+ const filePath = ""./file/secret/password"";
+ fs.readFile(filePath, (err, data) => {
+ if (err) {
+ // 에러 내용을 그대로 전달하지 않고 필터링 처리
+ return res.status(500).send({ message: “잘못된 요청입니다” });
+ } else {
+ return res.send(data);
+ }
+ })
+});"
+Javascript,에러처리,오류 메시지 정보노출,"오류메시지나 스택정보에 시스템 내부구조가 포함되어 민감한 정보, 디버깅 정보가 노출 가능한 보안약점",Express에서 제공하는 errorHandler 미들웨어를 정의하지 않음.,"const express = require(""express"");
+const app = express();
+// errorHandler 미들웨어는 다른 app.use() 및 라우터 정의 후 가장 마지막에 정의해야 하며, // errorHandler 미들웨어를 커스텀하여 에러별 에러페이지를 반환할 수 있다
+app.use(clientErrorHandler);
+app.use(errorHandler);
+function clientErrorHandler (err, req, res, next) {
+ if (req.xhr) {
+ res.status(500).send({ error: 'Something failed!' });
+ } else {
+ next(err);
+ }
+}
+function errorHandler (err, req, res, next) {
+ if (err.name = ""ValidError"") {
+ res.status(400)
+ res.render('400error', { error: err })
+ } else if (err.name = ""AuthError"") {
+ res.status(401)
+ res.render('401error', { error: err })
+ } else if (err.name = ""ForbiddenError"") {
+ res.status(403)
+ res.render('403error', { error: err })
+ } else if (err.name = ""DBError"") {
+ res.status(500)
+ res.render('500error', { error: err })
+ }
+}"
+Javascript,에러처리,오류상황 대응 부재,시스템 오류상황을 처리하지 않아 프로그램 실행정지 등 의도하지 않은 상황이 발생 가능한 보안약점,"const express = require('express');
+const crypto = require(""crypto"");
+const staticKeys = [
+ { ""key"" : ""a6823ecf34012b1ca5ca7889f4eabb51"", ""iv"" : ""e79ce03b4563647a"" },
+ { ""key"" : ""9e7c30e899f296a1daca7d9a0f92e71c"", ""iv"" : ""ab39941053fb5f6a"" }
+ ];
+router.post(""/vuln"", (req, res) => {
+ let statickKey = { ""key"" : ""00000000000000000000000000000000"", ""iv"" : ""0000000000000000"" };
+ const inputText = req.body.text;
+ const keyId = req.body.id;
+ try {
+ staticKey.key = staticKeys[keyId].key;
+ staticKey.iv = staticKeys[keyId].iv;
+ } catch (err) {
+ // key 선택 중 오류 발생 시 기본으로 설정된 암호화 키인
+ // ‘0000000000000000’ 으로 암호화가 수행됨
+ console.log(err);
+ }
+ const cipher = crypto.createCipheriv('aes-256-cbc', statickKey.key, statickKey.iv);
+ const encryptedText = cipher.update(inputText, 'utf8', 'base64') + cipher.final('base64');
+
+ return res.send(encryptedText);
+});","const express = require('express');
+const crypto = require(""crypto"");
+const staticKeys = [
+ { ""key"" : ""a6823ecf34012b1ca5ca7889f4eabb51"", ""iv"" : ""e79ce03b4563647a"" },
+ { ""key"" : ""9e7c30e899f296a1daca7d9a0f92e71c"", ""iv"" : ""ab39941053fb5f6a"" }
+ ];
+router.post(""/vuln"", (req, res) => {
+ let statickKey = { ""key"" : ""00000000000000000000000000000000"", ""iv"" : ""0000000000000000""
+};
+ const inputText = req.body.text;
+ const keyId = req.body.id;
+ try {
+ staticKey.key = staticKeys[keyId].key;
+ staticKey.iv = staticKeys[keyId].iv;
+ } catch (err) {
+ // 키 선택 중 오류 발생 시 랜덤으로 암호화 키를 생성하도록 설정
+ staticKey.key = crypto.randomBytes(16).toString('hex');
+ staticKey.iv = crypto.randomBytes(8).toString('hex');
+ }
+ const cipher = crypto.createCipheriv('aes-256-cbc', statickKey.key, statickKey.iv);
+ const encryptedText = cipher.update(inputText, 'utf8', 'base64') + cipher.final('base64');
+
+ return res.send(encryptedText);
+});"
+Javascript,에러처리,부적절한 예외처리,예외사항을 부적절하게 처리하여 의도하지 않은 상황이 발생 가능한 보안약점,"const express = require('express');
+router.post(""/vuln"", (req, res) => {
+ const password = req.body.password;
+ const user = {
+ user: ""user"",
+ password: password,
+ };
+ function getUser() {
+ return new Promise((resolve, reject) => {
+ resolve(user);
+ });
+ }
+ function getUserPassword(user) {
+ return new Promise((resolve, reject) => {
+ if (user.password === undefined) {
+ reject(new Error(""login fail""));
+ } else {
+ resolve(user);
+ }
+ });
+ }
+function checkPassword(user) {
+ return new Promise((resolve, reject) => {
+ if (user.password == ""abc"") {
+ resolve(user);
+ } else {
+ reject(new Error(""login fail""));
+ }
+ });
+ }
+ return getUser()
+ .then(getUserPassword)
+ .then(checkPassword)
+ .then((result) => res.send(result))
+ .catch((err) => {
+ // 서로 다른 예외 상황에서도 동일한 에러 메시지만 출력
+ res.send(err.message);
+ });
+});","const express = require('express');
+router.post(""/patched"", (req, res) => {
+ const password = req.body.password;
+ const user = {
+ user: ""user"",
+ password: password,
+ };
+ function getUser() {
+ return new Promise((resolve, reject) => {
+ resolve(user);
+ });
+ }
+ function getUserPassword(user) {
+ return new Promise((resolve, reject) => {
+ if (user.password === undefined) {
+ reject(new Error(""password required""));
+ }
+ resolve(user);
+ });
+ }
+ function checkPassword(user) {
+ return new Promise((resolve, reject) => {
+ if (user.password == ""abc"") {
+ resolve(user);
+ } else {
+ reject(new Error(""wrong password""));
+ }
+ });
+ }
+ return getUser()
+ .then(getUserPassword)
+ .then(checkPassword)
+ .then((result) => res.send(result))
+ .catch((err) => {
+ // 예외 상황에 맞는 처리 결과 메시지를 로그에 기록(내장 함수 log가 있다고 가정)
+ log(err.messsage);
+ // 클라이언트에는 에러 발생 여부만 전달
+ res.send(‘login failed’);
+ });
+);"
+Javascript,코드오류,Null Pointer 역참조,변수의 주소 값이 Null인 객체를 참조하는 보안약점,"const express = require('express');
+router.get(""/vuln"", (req, res) => {
+ const id = req.query.id;
+ // 사용자가 id 값을 전달하지 않을 경우(undefined) 에러 발생
+ return res.send(""length = "" + id.length);
+});","const express = require('express');
+ router.get(""/patched"", (req, res) => {
+ const id = req.query.id;
+ if (id === undefined) {
+ // id 값이 전달되지 않을 경우 사용자에게 요구하는 예외 코드 추가
+ return res.send(""id is required"");
+ } else {
+ return res.send(""length = "" + id.length);
+ }
+});"
+Javascript,코드오류,부적절한 자원 해제,사용 완료된 자원을 해제하지 않아 자원이 고갈되어 새로운 입력을 처리할 수 없는 보안약점,"const express = require('express');
+const fs = require('fs');
+router.get(""/vuln"", (req, res) => {
+ const configPath = './config.cfg';
+ let fid = null;
+ let fdata = null;
+ try {
+ fid = fs.openSync(configPath, 'r');
+ fdata = fs.readFileSync(fid, 'utf8');
+ // 예외 발생 상황 가정: 유효하지 않은 파일 디스크립터로 파일 읽기 시도
+ fdata = fs.readFileSync('100', 'utf8');
+ // try 절에서 할당된 자원이 반환(close)되기 전에 예외가 발생하면
+ // 할당된 자원이 시스템에 바로 반환되지 않음
+ fs.close(fid, err => {
+ if (err) {
+ console.log('error occured while flle closing');
+ } else {
+ console.log('file closed');
+ }
+ });
+ } catch (e) {
+ console.log('error occured!' , e);
+ }
+ return res.send(fdata);
+});","const express = require('express');
+const fs = require('fs');
+router.get(""/patched"", (req, res) => {
+ const configPath = './5_code_error/40_improper_resource_shutdown/config.cfg';
+ let fid = null;
+ let fdata = null;
+ try {
+ fid = fs.openSync(configPath, 'r');
+ fdata = fs.readFileSync(fid, 'utf8');
+ fdata = fs.readFileSync(100, 'utf8');
+ } catch (e) {
+ console.log('error occured!' , e);
+
+ // try 절에서 할당된 자원은 finally 절에서 시스템에 반환을 해야 함
+ } finally {
+ fs.close(fid, err => {
+ if (err) {
+ console.log('error occured while flle closing');
+ } else {
+ console.log('file closed');
+ }
+ });
+ }
+ return res.send(fdata);
+});"
+Javascript,코드오류,"신뢰할 수 없는
+데이터의 역직렬화","악의적인 코드가 삽입·수정된 직렬화 데이터를 적절한 검증 없이 역직렬화하여 발생하는 보안약점
+* 직렬화: 객체를 전송 가능한 데이터형식으로 변환
+* 역직렬화: 직렬화된 데이터를 원래 객체로 복원","const express = require('express');
+def load_user_object(request):
+ const serializedData = req.query.data;
+ # 사용자로부터 입력받은 알 수 없는 데이터를 역직렬화
+ const user = JSON.parse(serializedData);
+ return res.send({user: user.user, isAdmin: user.isAdmin});","const express = require('express');
+const crypto = require('crypto');
+def load_user_object(request):
+const serializedData = req.query.data;
+# 데이터 형식: '{""userInfo"":{""user"":""admin"",""isAdmin"":true},""hashed"":""cf8cd...7""}';
+ const body = JSON.parse(serializedData);
+ # 데이터 변조를 확인하기 위한 해시값
+ const hashedMac = body.hashed;
+ # 사용자로부터 입력받은 데이터를 직렬화
+ const userInfo = JSON.stringify(body.userInfo);
+ const secretKey = 'secret_key';
+ const hmac = crypto.createHmac('sha512', secretKey);
+ # 직렬화된 사용자 입력값을 해싱
+hmac.update(userInfo);
+const calculatedHMAC = hmac.digest('hex');
+# 전달받은 해시값(hashedMAC)과 직렬화 데이터(calculaedHMAC)의 해시값을 비교하여 검증
+if (calculatedHMAC === hashedMac) {
+ const userObj = JSON.parse(userInfo);
+ return res.send(userObj);
+} else {
+ console.log('hmac -', calculatedHMAC);
+ return res.send('신뢰할 수 없는 데이터입니다. ');
+ }"
+Javascript,캡슐화,"잘못된 세션에 의한
+데이터 정보노출",잘못된 세션에 의해 인가되지 않은 사용자에게 중요정보가 노출 가능한 보안약점,"let instance;
+class UserSingleton {
+ constructor() {
+ this.userName = 'testUser';
+ if (instance) {
+ return instance;
+ }
+ instance = this;
+ }
+ getUserProfile() {
+ return this.userName;
+ }
+};
+router.get(""/vuln"", (req, res) => {
+ const user = new UserSingleton();
+ const profile = user.getUserProfile();
+ // 서로 다른 세션에서 공유되는 값을 사용하는 경우 다른 세션에 의해 데이터가 노출될 수 있음
+ return res.send(profile);
+});","class User {
+ constructor() {
+ this.userName = 'testUser';
+ }
+ getUserProfile() {
+ return this.userName;
+ }
+};
+router.get(""/patched"", (req, res) => {
+ const user = new User();
+ const profile = user.getUserProfile();
+ // 서로 다른 세션에서 공유되지 않는 클래스 정의를 사용해 안전함
+ return res.send(profile);
+});"
+Javascript,캡슐화,"제거되지 않고 남은
+디버그 코드",디버깅을 위한 코드를 제거하지 않아 인가되지 않은 사용자에게 중요정보가 노출 가능한 보안약점,"디버깅 목적으로 삽입된 코드는 개발이 완료되면 제거해야 한다. 디버그 코드는 설정 등의 민감한 정보 또는
+의도하지 않은 시스템 제어로 이어지는 정보를 담고 있을 수 있다. 만일 디버그 코드가 남겨진 채로 배포될
+경우 공격자가 식별 과정을 우회하거나 의도하지 않은 정보 노출 문제가 발생할 수 있다. 기본적으로 자바스크립트에서는 console.log 또는 console.error 함수를 사용해 디버그 메시지를 출력한다. 개발 완료 후에 디버깅용으로 작성한 코드를 오버라이드(override) 해 애플리케이션 동작 시 콘솔 로그가 출력
+되지 않도록 한다. 또한 기본적으로 ExpressJS는 디버그 모드가 비활성화 된 상태에서 동작하며 서버 구동 시
+‘DEBUG=’ prefix 설정을 하지 않는 한 서버 디버깅 메시지는 출력하지 않는다.","// 애플리케이션 진입 코드인 Index.js에 다음 코드를 추가하면
+// 코드 내에 삭제되지 않은 모든 console.log 코드로 인해 아무런 내용도 출력되지 않음
+//  ReactJS 예제
+if (process.env.NODE_ENV === ‘production’ && typeof window !== ‘undefined’) {
+ console.log = () => {};
+}"
+Javascript,캡슐화,"제거되지 않고 남은
+디버그 코드",디버깅을 위한 코드를 제거하지 않아 인가되지 않은 사용자에게 중요정보가 노출 가능한 보안약점,"디버깅 목적으로 삽입된 코드는 개발이 완료되면 제거해야 한다. 디버그 코드는 설정 등의 민감한 정보 또는
+의도하지 않은 시스템 제어로 이어지는 정보를 담고 있을 수 있다. 만일 디버그 코드가 남겨진 채로 배포될
+경우 공격자가 식별 과정을 우회하거나 의도하지 않은 정보 노출 문제가 발생할 수 있다. 기본적으로 자바스크립트에서는 console.log 또는 console.error 함수를 사��해 디버그 메시지를 출력한다. 개발 완료 후에 디버깅용으로 작성한 코드를 오버라이드(override) 해 애플리케이션 동작 시 콘솔 로그가 출력
+되지 않도록 한다. 또한 기본적으로 ExpressJS는 디버그 모드가 비활성화 된 상태에서 동작하며 서버 구동 시
+‘DEBUG=’ prefix 설정을 하지 않는 한 서버 디버깅 메시지는 출력하지 않는다.","// 서버 진입 코드인 index.js 내의 서버 구동 부분에 다음 코드 추가
+// ExpressJS 예제
+app.listen(80, () => {
+ if (!process.env.DEBUG) {
+ console.log = function(){}
+ }
+});"
+Javascript,캡슐화,Public 메소드로부터 반환된 Private 배열,"Public으로 선언된 메소드에서 Private로 선언된 배열을 반환(return)하면 Private 배열의 주소
+값이 외부에 노출되어 해당 Private 배열값을 외부에서 수정 가능한 보안약점","class UserObj {
+ #privArray = [];
+
+ // private 배열을 리턴하는 public 메소드를 사용하는 경우 취약
+ get_private_member = () => {
+ return this.#privArray;
+ }
+}","class UserObj {
+ #privArray = [];
+
+ // private 배열을 반환하는 경우 복사본을 사용해 외부와 내부의
+ // 배열이 서로 참조되지 않도록 해야 함
+ get_private_member = () => {
+ const copied = Object.assign([], this.#privArray);
+ return copied;
+ }
+}"
+Javascript,캡슐화,"Private 배열에 Public
+데이터 할당",Public으로 선언된 데이터 또는 메소드의 인자가 Private로 선언된 배열에 저장되면 Private 배열을 외부에서 접근하여 수정 가능한 보안약점,"class UserObj {
+ #privArray = [];
+ // private 배열에 외부 값을 바로 대입하는 public 메소드를 사용하는 경우 취약
+ set_private_member = (input_list) => {
+ this.#privArray = input_list;
+ }
+}","class UserObj2 {
+ #privArray = [];
+ // 사용자가 전달한 값을 private가 아닌 public 배열로 저장
+ set_private_member = (input_list) => {
+ this.userInput = input_list;
+ }
+}"
+Javascript,API 오용,"DNS lookup에 의존한
+보안결정",도메인명 확인(DNS lookup)으로 보안결정을 수행할 때 악의적으로 변조된 DNS 정보로 예기치 않은 보안위협에 노출되는 보안약점,"const express = require('express');
+const dns = require(""dns"");
+router.get(""/vuln"", (req, res) => {
+ let trusted = false;
+ const trustedHost = ""www.google.com"";
+ const hostName = req.query.host;
+ // 공격자에 의해 실행되는 서버의 DNS가 변경될 수 있으므로 
+ // 안전하지 않음
+ if (hostName === trustedHost) {
+ trusted = true;
+ }
+ return res.send({trusted});
+});","const express = require('express');
+const dns = require(""dns"");
+router.get(""/patched"", async (req, res) => {
+ let trusted = false;
+ const trustedHost = ""142.250.207.100"";
+ // 실제 서버의 IP 주소를 비교하여 DNS 변조에 대응
+async function dnsLookup() {
+ return new Promise((resolve, reject) => {
+ dns.lookup(req.query.host, 4, (err, address, family) => {
+ if (err) reject(err);
+ resolve(address);
+ })
+ })
+ }
+ const hostName = await dnsLookup();
+ if (hostName === trustedHost) {
+ trusted = true;
+ }
+ return res.send({trusted});
+});"
+Javascript,API 오용,취약한 API 사용,eval() 함수의 부적절한 사용,"const userInput = ""2 + 2"";
+const result = eval(userInput); // 사용자 입력을 평가하여 실행
+console.log(result);","const math = require('mathjs');
+const userInput = ""2 + 2"";
+const result = math.evaluate(userInput); // 안전한 수학 표현식 평가
+console.log(result);"
+Javascript,API 오용,취약한 API 사용,innerHTML 속성의 부적절한 사용,"const userInput = ""<img src='x' onerror='alert(1)'>"";
+document.getElementById('output').innerHTML = userInput;","const userInput = ""<img src='x' onerror='alert(1)'>"";
+const outputElement = document.getElementById('output');
+const textNode = document.createTextNode(userInput);
+outputElement.appendChild(textNode);"
+Javascript,API 오용,취약한 API 사용,setTimeout() 및 setInterval() 함수의 부적절한 사용,"const userInput = ""alert('Hello')"";
+setTimeout(userInput, 1000); // 사용자 입력을 코드로 실행","const userInput = ""Hello"";
+setTimeout(() => {
+  alert(userInput);
+}, 1000);"
+Javascript,API 오용,취약한 API 사용,Function 생성자의 부적절한 사용,"const userInput = ""return 2 + 2"";
+const func = new Function(userInput);
+console.log(func());","const userInput = ""2 + 2"";
+const result = eval(userInput); // eval 사용은 지양해야 하지만, 예시를 위해 사용
+console.log(result);"
+Javascript,API 오용,취약한 API 사용,document.write() 함수의 부적절한 사용,"const userInput = ""<script>alert('XSS')</script>"";
+document.write(userInput);","const userInput = ""Hello, World!"";
+const outputElement = document.getElementById('output');
+const textNode = document.createTextNode(userInput);
+outputElement.appendChild(textNode);"
+Python,입력데이터 검증 및 표현,SQL 삽입,"SQL 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이 실행가능한
+보안약점","from django.shortcuts import render
+from django.db import connection
+def update_board(request):
+ ......
+ dbconn = connection
+
+ with dbconn.cursor() as curs:
+ # 외부로부터 입력받은 값을 검증 없이 사용할 경우 안전하지 않다
+    name = request.POST.get('name', '')       content_id = request.POST.get('content_id', '')       # 사용자의 검증되지 않은 입력값을 사용해 동적 쿼리문 생성
+      sql_query = ""update board set name='"" + name + ""' where content_id='“ + content_id + ""'""
+    # 외부 입력값이 검증 없이 쿼리로 포함되어 안전하지 않다
+    curs.execute(sql_query)     dbconn.commit()
+    return render(request, '/success.html')","from django.shortcuts import render
+from django.db import connection
+def update_board(request):   ......
+ dbconn = connection
+ with dbconn.cursor() as curs:
+ name = request.POST.get('name', '')
+ content_id = request.POST.get('content_id', '')
+ # 외부 입력값 조작으로부터 안전한 인자화된 쿼리를 생성한다.
+ sql_query = 'update board set name=%s where content_id=%s'
+ # 사용자의 입력값이 인자화된 쿼리에 바인딩 후 실행되므로 안전하다.
+ curs.execute(sql_query, (name, content_id))
+ dbconn.commit()
+ return render(request, '/success.html')"
+Python,입력데이터 검증 및 표현,SQL 삽입,"SQL 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이 실행가능한
+보안약점","from django.shortcuts import render
+from app.models import Member
+def member_search(request):
+name = request.POST.get('name', '')
+# 입력값을 검증 없이 쿼리문 생성에 사용해 안전하지 않다
+query=“select * from member where name=‘” + name + “’” # 외부 입력값을 검증 없이 사용한 쿼리문을 raw()함수로 실행하면 안전하지 않다
+    data = Member.objects.raw(query)
+return render(request, '/member_list.html', {'member_list':data})","from django.shortcuts import render
+from app.models import Member
+def member_search(request):
+ name = request.POST.get('name', '')
+# 외부 입력값을 raw() 함수 실행 시 바인딩 변수로 사용하여 쿼리 구조가
+ # 변경되지 않도록 한다.(list 형은 %s, dictionary 형은 %(key)s를 사용)
+ query='select * from member where name=%s'
+ # 인자화된 쿼리문을 사용하여 raw() 함수를 호출해 안전하다
+ data = Member.objects.raw(query, [name])
+return render(request, '/member_list.html', {'member_list':data})"
+Python,입력데이터 검증 및 표현,코드 삽입,"프로세스가 외부 입력값을 코드(명령어)로 해석·실행할 수 있고 프로세스에 검증되지 않은 외부
+입력값을 허용한 경우 악의적인 코드가 실행 가능한 보안약점","from django.shortcuts import render
+def route(request):
+ # 외부에서 입력받은 값을 검증 없이 사용하면 안전하지 않다
+ message = request.POST.get('message', '')
+ # 외부 입력값을 검증 없이 eval 함수에 전달할 경우 의도하지 않은 코드가
+ # 실행될 수 있어 위험하다
+ ret = eval(message)
+ return render(request, '/success.html', {'data':ret})","from django.shortcuts import render
+def route(request):
+ message = request.POST.get('message', '')
+ # 사용자 입력을 영문, 숫자로 제한하며, 만약 입력값 내에 특수문자가 포함되어
+ # 있을 경우 에러 메시지를 반환 한다
+ if message.isalnum():
+ ret = eval(message)
+ return render(request, '/success.html', {'data':ret})
+
+ return render(request, '/error.html')"
+Python,입력데이터 검증 및 표현,코드 삽입,"프로세스가 외부 입력값을 코드(명령어)로 해석·실행할 수 있고 프로세스에 검증되지 않은 외부
+입력값을 허용한 경우 악의적인 코드가 실행 가능한 보안약점","from django.shortcuts import render
+def request_rest_api(request):
+ function_name = request.POST.get('function_name', '')
+ # 사용자에게 전달받은 함수명을 검증하지 않고 실행
+ # 입력값으로 “__import__(‘platform’).system()” 등을 입력 시
+ # 시스템 정보 노출 위험이 있다
+ exec('{}()'.format(function_name))
+
+ return render(request, '/success.html')","from django.shortcuts import render
+WHITE_LIST = ['get_friends_list', 'get_address', 'get_phone_number']
+def request_rest_api(request):
+ function_name = request.POST.get('function_name', '')
+ # 사용 가능한 함수를 화이트리스트 목록 내의 함수로 제한
+ if function_name in WHITE_LIST:
+ exec('{}()'.format(function_name))
+ return render(request, '/success.html')
+
+ return render(request, '/error.html', {'error':'허용되지 않은 함수입니다.'})"
+Python,입력데이터 검증 및 표현,경로 조작 및 자원 삽입,"시스템 자원 접근경로 또는 자원제어 명령어에 검증되지 않은 외부 입력값을 허용하여 시스템
+자원에 무단 접근 및 악의적인 행위가 가능한 보안약점","import os
+from django.shortcuts import render
+def get_info(request):
+ # 외부 입력값으로부터 파일명을 입력 받는다
+ request_file = request.POST.get('request_file')
+ (filename, file_ext) = os.path.splitext(request_file)
+ file_ext = file_ext.lower()
+ if file_ext not in ['.txt', '.csv']:
+ return render(request, '/error.html', {'error':'파일을 열 수 없습니다.'})
+# 입력값을 검증 없이 파일 처리에 사용했다
+ with open(request_file) as f:
+ data = f.read()
+
+ return render(request, '/success.html', {'data':data})","import os
+from django.shortcuts import render
+
+def get_info(request):
+	request_file = request.POST.get('request_file')
+	(filename, file_ext) = os.path.splitext(request_file)
+	file_ext = file_ext.lower()
+	# 외부 입력값으로 받은 파일 이름은 검증하여 사용한다.
+	if file_ext not in ['.txt', '.csv']:
+		return render(request, '/error.html', {'error':'파일을 열수 없습니다.'})
+	# 파일 명에서 경로 조작 문자열을 필터링 한다.
+	filename = filename.replace('.', '')
+	filename = filename.replace('/', '')
+	filename = filename.replace('\\', '')
+	try:
+		with open(filename + file_ext) as f:
+			data = f.read()
+	except Exception:
+		return render(
+			request, ""/error.html"", {""error"": ""파일이 존재하지 않거나 열 수 없는 파일입니다.""}
+		)
+	return render(request, '/success.html', {'data':data})"
+Python,입력데이터 검증 및 표현,경로 조작 및 자원 삽입,"시스템 자원 접근경로 또는 자원제어 명령어에 검증되지 않은 외부 입력값을 허용하여 시스템
+자원에 무단 접근 및 악의적인 행위가 가능한 보안약점","import socket
+from django.shortcuts import render
+def get_info(request):
+ port = int(request.POST.get('port'))
+ with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+ # 외부로부터 입력받은 검증되지 않은 포트 번호를 이용하여
+ # 소켓을 바인딩하여 사용하고 있어 안전하지 않다
+ s.bind(('127.0.0.1', port))
+ ...
+ return render(request, '/success.html')
+ return render(request, '/error.html', {'error':'소켓연결 실패'})","import socket
+from django.shortcuts import render
+ALLOW_PORT = [4000, 6000, 9000]
+def get_info(request):
+ port = int(request.POST.get('port'))
+ # 사용 가능한 포트 번호를 화이트리스트 내의 포트로 제한
+ if port not in ALLOW_PORT:
+ return render(request, '/error.html', {'error':'소켓연결 실패'})
+ with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+ s.bind(('127.0.0.1', port))
+ ......
+ return render(request, '/success.html')"
+Python,입력데이터 검증 및 표현,크로스사이트 스크립트(XSS),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한
+보안약점","from django.shortcuts import render
+from django.utils.safestring import mark_safe
+def profile_link(request):
+ # 외부 입력값을 검증 없이 HTML 태그 생성의 인자로 사용
+ profile_url = request.POST.get('profile_url')
+ profile_name = requst.POST.get('profile_name')
+
+ object_link = '<a href=""{}"">{}</a>'.format(profile_url, profile_name)
+ # mark_safe함수는 Django의 XSS escape 정책을 따르지 않는다
+ object_link = mark_safe(object_link)
+
+ return render(request, 'my_profile.html',{'object_link':object_link})","from django.shortcuts import render
+def profile_link(request):
+ # 외부 입력값을 검증 없이 HTML 태그 생성의 인자로 사용
+ profile_url = request.POST.get('profile_url')
+ profile_name = requst.POST.get('profile_name')
+
+ object_link = '<a href=""{}"">{}</a>'.format(profile_url, profile_name)
+ # 신뢰할 수 없는 데이터에 대해서는 mark_safe 함수를 사용해선 안 된다
+
+ return render(request, 'my_profile.html',{'object_link':object_link})"
+Python,입력데이터 검증 및 표현,크로스사이트 스크립트(XSS),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한
+보안약점","<!doctype html>
+<html>
+ <body>
+ <div class=""content"">
+ {% autoescape off %}
+ <!-- autoescape off로 설정하면 해당 블록내의 데이터는 XSS 공격에
+ 노출될 수 있다 -->
+ {{ content }}
+ {% endautoescape %}
+ </div>
+ <div class=""content2"">
+ <!-- safe 필터 사용으로 XSS 공격에 노출될 수 있다 -->
+ {{ content | safe }}
+ </div>
+ </body>
+</html>","<!doctype html>
+<html>
+ <body>
+ <div class=""content"">
+ {% autoescape on %}
+ <!--autoescape on으로 해당 블록내의 데이터는 XSS 공격에 노출되지 않음. -->
+ {{ content }}
+ {% endautoescape %}
+ </div>
+ <div class=""content2"">
+ <!-- 검증되지 않은 데이터에는 safe 필터를 사용하지 않는다. -->
+ {{ content }}
+ </div>
+ </body>
+</html>"
+Python,입력데이터 검증 및 표현,크로스사이트 스크립트(XSS),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한
+보안약점","from flask import Flask, request, render_template
+@app.route('/search', methods=['POST'])
+def search():
+search_keyword = request.form.get('search_keyword')
+# 사용자의 입력을 아무런 검증 또는 치환 없이 동적 웹페이지에 사용하고 있어
+# XSS 공격이 발생할 수 있다
+return render_template('search.html', search_keyword=search_keyword)","import html
+from flask import Flask, request, render_template
+@app.route('/search', methods=['POST'])
+def search():
+ search_keyword = request.form.get('search_keyword')
+# 동적 웹페이지 생성에 사용되는 데이터는
+# HTML 엔티티코드로 치환하여 표현해야 한다
+escape_keyword = html.escape(search_keyword)
+return render_template('search.html', search_keyword=escape_keyword)"
+Python,입력데이터 검증 및 표현,운영체제 명령어 삽입,"운영체제 명령어를 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 명령어가 실행
+가능한 보안약점","import os
+from django.shortcuts import render
+def execute_command(request):
+ app_name_string = request.POST.get('app_name','')
+# 입력 파라미터를 제한하지 않아 외부 입력값으로 전달된
+ # 모든 프로그램이 실행될 수 있음
+os.system(app_name_string)
+return render(request, '/success.html')","import os
+from django.shortcuts import render
+ALLOW_PROGRAM = ['notepad', 'calc']
+def execute_command(request):
+ app_name_string = request.POST.get('app_name','')
+ # 입력받은 파라미터가 허용된 시스템 명령어 목록에 포함되는지 검사
+ if app_name_string not in ALLOW_PROGRAM:
+ return render(request, '/error.html', {'error':'허용되지 않은 프로그램입니다.'})
+ os.system(app_name_string)
+ return render(request, '/success.html')"
+Python,입력데이터 검증 및 표현,운영체제 명령어 삽입,"운영체제 명령어를 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 명령어가 실행
+가능한 보안약점","import subprocess
+from django.shortcuts import render
+def execute_command(request):
+ date = request.POST.get('date','')
+ # 입력받은 파라미터를 제한하지 않아 전달된 모든 프로그램이 실행될 수 있음
+ cmd_str = “cmd /c backuplog.bat ” + date
+ subprocess.run(cmd_str, shell=True)
+ return render(request, '/success.html')","import subprocess
+from django.shortcuts import render
+def execute_command(request):
+ date = request.POST.get('date','')
+ # 명령어를 추가로 실행 또는 또 다른 명령이 실행될 수 있는 키워드에
+ # 대한 예외처리
+ for word in ['|', ';', '&', ':', '>', '<', '`', '\\', '!']:
+ date = date.replace(word, “”)
+ # re.sub 함수를 사용해 특수문자를 제거하는 방법도 있다
+ # date = re.sub('[|;&:><`\\\!]', '', date)
+ # shell=True 옵션은 제거 하고 명령과 인자를 배열로 입력
+ subprocess.run([""cmd"", ""/c"", ""backuplog.bat"", date])
+ return render(request, '/success.html')"
+Python,입력데이터 검증 및 표현,위험한 형식 파일 업로드,파일의 확장자 등 파일형식에 대한 검증없이 파일 업로드를 허용하여 공격이 가능한 보안약점,"from django.shortcuts import render
+from django.core.files.storage import FileSystemStorage
+def file_upload(request):
+ if request.FILES['upload_file']:
+ # 사용자가 업로드하는 파일을 검증 없이 저장하고 있어
+ # 안전하지 않다
+ upload_file = request.FILES['upload_file']
+ fs = FileSystemStorage(location='media/screenshot', base_url='media/screenshot')
+ # 업로드 하는 파일에 대한 크기, 개수, 확장자 등을 검증하지 않음
+ filename = fs.save(upload_file.name, upload_file)
+ return render(request, '/success.html', {'filename':filename})
+ return render(request, '/error.html', {'error':'파일 업로드 실패'})","import os
+from django.shortcuts import render
+from django.core.files.storage import FileSystemStorage
+# 업로드 하는 파일 개수, 크기, 확장자 제한
+FILE_COUNT_LIMIT = 5
+# 업로드 하는 파일의 최대 사이즈 제한 예 ) 5MB - 5*1024*1024
+FILE_SIZE_LIMIT = 5242880
+# 허용하는 확장자는 화이트리스트로 관리한다. 
+WHITE_LIST_EXT = [
+	'.jpg',
+	'.jpeg' 
+]
+def file_upload(request):
+	# 파일 개수 제한
+	if len(request.FILES) == 0 or len(request.FILES) > FILE_COUNT_LIMIT:
+		return render(request, '/error.html', {'error': '파일 개수 초과'})
+	
+	for filename, upload_file in request.FILES.items():
+		# 파일 타입 체크
+		if upload_file.content_type != 'image/jpeg':
+			return render(request, '/error.html', {'error': '파일 타입 오류'})
+		# 파일 크기 제한
+		if upload_file.size > FILE_SIZE_LIMIT:
+			return render(request, '/error.html', {'error': '파일사이즈 오류'})
+		# 파일 확장자 검사
+		file_name, file_ext = os.path.splitext(upload_file.name)
+		if file_ext.lower() not in WHITE_LIST_EXT:
+			return render(request, '/error.html', {'error': '파일 타입 오류'})
+		
+	fs = FileSystemStorage(location='media/screenshot', base_url = 'media/screenshot')
+	for upload_file in request.FILES.values():
+		filename = fs.save(upload_file.name, upload_file)
+		filename_list.append(filename)
+	return render(request, ""/success.html"", {""filename_list"": filename_list})"
+Python,입력데이터 검증 및 표현,신뢰되지 않은 URL주소로 자동접속 연결,"URL 링크 생성에 검증되지 않은 외부 입력값을 허용하여 악의적인 사이트로 자동 접속 가능한
+보안약점","from django.shortcuts import redirect
+def redirect_url(request):
+ url_string = request.POST.get('url', '')
+ # 사용자 입력에 포함된 URL 주소로 리다이렉트 하는 경우
+ # 피싱 사이트로 접속되는 등 사용자가 피싱 공격에 노출될 수 있다
+ return redirect(url_string)","from django.shortcuts import render, redirect
+ALLOW_URL_LIST = [
+ '127.0.0.1',
+ '192.168.0.1',
+ '192.168.0.100',
+ 'https://login.myservice.com',
+ '/notice',
+]
+def redirect_url(request):
+ url_string = request.POST.get('url', '')
+ # 이동할 수 있는 URL 범위를 제한하여
+ # 위험한 사이트의 접근을 차단하고 있다
+ if url_string not in ALLOW_URL_LIST:
+ return render(request, '/error.html', {'error':'허용되지 않는 주소입니다.'})
+
+ return redirect(url_string)"
+Python,입력데이터 검증 및 표현,부적절한 XML 외부 개체 참조,임의로 조작된 XML 외부개체에 대한 적절한 검증 없이 참조를 허용하여 공격이 가능한 보안약점,"<?xml version=""1.0"" encoding=""ISO-8859-1""?>
+<!DOCTYPE foo [
+ <!ELEMENT foo ANY >
+ <!ENTITY xxe1 SYSTEM ""file:///etc/passwd"" >
+ <!ENTITY xxe2 SYSTEM ""http://attacker.com/text.txt"">
+]>
+<foo>&xxe1;&xxe2;</foo>
+
+
+from xml.sax import make_parser
+from xml.sax.handler import feature_external_ges
+from xml.dom.pulldom import parseString, START_ELEMENT
+from django.shortcuts import render
+from .model import comments
+def get_xml(request):
+    if request.method == ""GET"":
+        data = comments.objects.all()
+        com = data[0].comment
+        return render(request, '/xml_view.html', {'com': com})
+    elif request.method == ""POST"":
+        parser = make_parser()
+        # 외부 일반 엔티티를 포함하는 설정을 True로 적용할 경우 취약하다
+        parser.setFeature(feature_external_ges, True)
+        doc = parseString(request.body.decode('utf-8'), parser=parser)
+        for event, node in doc:
+            if event == START_ELEMENT and node.tagName == ""foo"":
+                doc.expandNode(node)
+                text = node.toxml()
+                comments.objects.filter(id=1).update(comment=text)
+        return render(request, '/xml_view.html')","from xml.sax import make_parser
+from xml.sax.handler import feature_external_ges
+from xml.dom.pulldom import parseString, START_ELEMENT
+from django.shortcuts import render
+from .model import comments
+def get_xml(request):
+ if request.method == “GET”:
+ data = comments.objects.all()
+ com = data[0].comment
+ return render(request, '/xml_view.html', {'com':com})
+ elif request.method == “POST”:
+ parser = make_parser()
+ parser.setFeature(feature_external_ges, False)
+ doc = parseString(request.body.decode(‘utf-8’), parser=parser)
+ for event, node in doc:
+ if event == START_ELEMENT and node.tagName == “foo”:
+ doc.expandNode(node)
+ text = node.toxml()
+ comments.objects.filter(id=1).update(comment=text);
+ return render(request, '/xml_view.html')"
+Python,입력데이터 검증 및 표현,XML 삽입,"XQuery, XPath 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이
+실행 가능한 보안약점","from django.shortcuts import render
+from lxml import etree
+def parse_xml(request):
+ user_name = request.POST.get('user_name', '')
+ parser = etree.XMLParser(resolve_entities=False)
+ tree = etree.parse('user.xml', parser)
+ root = tree.getroot()
+ # 검증되지 않은 외부 입력값 user_name을 사용한 안전하지 않은
+ # 질의문이 query 변수에 저장
+ query = ""/collection/users/user[@name='"" + user_name + ""']/home/text()""
+ elmts = root.xpath(query)
+ return render(request, 'parse_xml.html', {'xml_element':elmts})","from django.shortcuts import render
+from lxml import etree
+def parse_xml(request):
+ user_name = request.POST.get('user_name', '')
+ parser = etree.XMLParser(resolve_entities=False)
+ tree = etree.parse('user.xml', parser)
+ root = tree.getroot()
+ # 외부 입력값을 paramname으로 인자화 해서 사용
+ query = '/collection/users/user[@name = $paramname]/home/text()' elmts = root.xpath(query, paramname=user_name)
+ return render(request, 'parse_xml.html', {'xml_element':elmts})"
+Python,입력데이터 검증 및 표현,LDAP 삽입,"LDAP 명령문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 명령어가 실행
+가능한 보안약점","from ldap3 import Connection, Server, ALL
+from django.shortcuts import render
+config = {
+ ""bind_dn"": ""cn=read-only-admin,dc=example,dc=com"",
+ ""password"": ""password"",
+}
+def ldap_query(request):
+ search_keyword = request.POST.get('search_keyword','')
+ dn = config['bind_dn']
+ password = config['password']
+ address = 'ldap.badSoruce.com'
+ server = Server(address, get_info=ALL)
+ conn = Connection(server, user=dn, password, auto_bind=True )
+# 사용자 입력을 필터링 하지 않는 경우 공격자의 권한 상승으로
+ # 이어질 수 있다
+ search_str = '(&(objectclass=%s))' % search_keyword
+ conn.search(
+ 'dc=company,dc=com',
+ search_str,
+ attributes=['sn', 'cn', 'address', 'mail', 'mobile', 'uid'],
+ )
+ return render(request, '/ldap_query_response.html', {'ldap':conn.entries})","from ldap3 import Connection, Server, ALL
+from ldap3.utils.conv import escape_filter_chars
+from django.shortcuts import render
+config = {
+ ""bind_dn"": ""cn=read-only-admin,dc=example,dc=com"",
+ ""password"": ""password"",
+}
+def ldap_query(request):
+ search_keyword = request.POST.get('search_keyword','')
+ dn = config['bind_dn']
+ password = config['password']
+ address = 'ldap.goodsource.com' server = Server(address, get_info=ALL)
+ conn = Connection(server, dn, password, auto_bind=True )
+ # 사용자의 입력에 필터링을 적용하여 공격에 사용될 수 있는 문자를
+ # 이스케이프하고 있다
+ escpae_keyword = escape_filter_chars(search_keyword)
+ search_str = '(&(objectclass=%s))' % escpae_keyword
+ conn.search(
+ 'dc=company,dc=com',
+ search_str,
+ attributes=['sn', 'cn', 'address', 'mail', 'mobile', 'uid'],
+ )
+ return render(request, '/ldap_query_response.html', {'ldap':conn.entries})"
+Python,입력데이터 검증 및 표현,크로스사이트 요청 위조(CSRF),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게
+공격자가 의도한 행위가 실행 가능한 보안약점","MIDDLEWARE = [
+ 'django.contrib.sessions.middleware.SessionMiddleware',
+ # MIDDLEWARE 목록에서 CSRF 항목을 삭제 또는 주석처리 하면
+ # Django 앱에서 CSRF 유효성 검사가 전역적으로 제거된다
+ # 'django.middleware.csrf.CsrfViewMiddleware',
+ 'django.contrib.auth.middleware.AuthenticationMiddleware',
+ 'django.contrib.messages.middleware.MessageMiddleware',
+ 'django.middleware.locale.LocaleMiddleware',
+ ...... ]","MIDDLEWARE = [
+ 'django.contrib.sessions.middleware.SessionMiddleware',
+ # MIDDLEWARE 목록에서 CSRF 항목을 활성화 한다
+ 'django.middleware.csrf.CsrfViewMiddleware',
+ 'django.contrib.auth.middleware.AuthenticationMiddleware',
+ 'django.contrib.messages.middleware.MessageMiddleware',
+ 'django.middleware.locale.LocaleMiddleware',
+ ...... ] "
+Python,입력데이터 검증 및 표현,크로스사이트 요청 위조(CSRF),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게
+공격자가 의도한 행위가 실행 가능한 보안약점","from django.shortcuts import render
+from django.views.decorators.csrf import csrf_exempt
+# csrf.exempt 데코레이터로 미들웨어에서 보호되는 CSRF 기능을 해제한다
+@csrf.exempt
+def pay_to_point(request):
+ user_id = request.POST.get('user_id', '')
+ pay = request.POST.get('pay', '')
+ product_info = request.POST.get('product_info', '')
+ ret = handle_pay(user_id, pay, product_info)
+ return render(request, '/view_wallet.html', {'wallet':ret})","from django.shortcuts import render
+from django.template import RequestContext
+# csrf_exempt 데코레이터를 삭제하거나 주석 처리한다. # @csrf_exempt
+def pay_to_point(request):
+ user_id = request.POST.get('user_id', '')
+ pay = request.POST.get('pay', '')
+ product_info = request.POST.get('product_info', '')
+ ret = handle_pay(user_id, pay, product_info)
+ return render(request, '/view_wallet.html', {'wallet':ret})"
+Python,입력데이터 검증 및 표현,크로스사이트 요청 위조(CSRF),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게
+공격자가 의도한 행위가 실행 가능한 보안약점","<!--html page-->
+<form action="""" method=""POST"">
+<!-- form 태그 내부에 csrf_token 미적용-->
+<table>
+{{form.as_table}}
+</table>
+<input type=""submit""/>
+</form>","<!--html page-->
+<form action="""" method=""POST"">     {% csrf_token %}  <!--csrf_token 사용->
+<table>
+{{form.as_table}}
+</table>
+<input type=""submit""/>
+</form>"
+Python,입력데이터 검증 및 표현,크로스사이트 요청 위조(CSRF),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게
+공격자가 의도한 행위가 실행 가능한 보안약점","from flask import Flask
+app = Flask(__name__)","from flask import Flask
+from flask_wtf.csrf import CSRFProtect
+# CSRF 설정 추가
+csrf = CSRFProtect(app)
+app = Flask(__name__)
+app.config[‘SECRET_KEY’] = os.environ.get('SECRET_KEY')
+csrf.init_app(app)"
+Python,입력데이터 검증 및 표현,크로스사이트 요청 위조(CSRF),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게
+공격자가 의도한 행위가 실행 가능한 보안약점","<form action="""" method=""POST"">
+<!-- form 태그 내부에 csrf_token 미적용-->
+<table>
+{{as_table}}
+</table>
+<input type=""submit""/>
+</form>","<form action="""" method=""POST"">
+ <!-- form 태그 내부에 csrf_token 적용-->
+<input type=""hidden"" name=""csrf_token"" value=""{{ csrf_token() }}"" />
+<table>
+{{table}}
+</table>
+<input type=""submit""/>
+</form>"
+Python,입력데이터 검증 및 표현,서버사이드 요청 위조,서버 간 처리되는 요청에 검증되지 않은 외부 입력값을 허용하여 공격자가 의도한 서버로 전송하거나 변조하는 보안약점,"from django.shortcuts import render
+import requests
+def call_third_party_api(request):
+ addr = request.POST.get('address', '')
+ # 사용자가 입력한 주소를 검증하지 않고 HTTP 요청을 보낸 후
+ # 응답을 사용자에게 반환
+ result = requests.get(addr).text
+ return render(request, '/result.html', {'result':result})","from django.shortcuts import render
+import requests
+# 허용하는 도메인을 화이트리스트에 정의할 경우 DNS rebinding 공격 등에
+# 노출될 위험이 있어 신뢰할 수 있는 자원에 대한 IP를 사용해
+# 검증하는 것이 조금 더 안전하다
+ALLOW_SERVER_LIST = [
+ 'https://127.0.0.1/latest/',
+ 'https://192.168.0.1/user_data',
+ 'https://192.168.0.100/v1/public',
+]
+def call_third_party_api(request):
+ addr = request.POST.get('address', '')
+ # 사용자가 입력한 URL을 화이트리스트로 검증한 후 그 결과를 반환하여
+ # 검증되지 않은 주소로 요청을 보내지 않도록 제한한다
+ if addr not in ALLOW_SERVER_LIST:
+ return render(request, '/error.html', {‘error’ = '허용되지 않은 서버입니다.'})
+
+ result = requests.get(addr).text
+ return render(request, '/result.html', {'result':result})"
+Python,입력데이터 검증 및 표현,HTTP 응답분할,HTTP 응답헤더에 개행문자(CR이나 LF)가 포함된 검증되지 않은 외부 입력값을 허용하여 악의적인 코드가 실행 가능한 보안약점,"from django.http import HttpResponse
+def route(request):
+ content_type = request.POST.get('content-type')
+ # 외부 입력값을 검증 또는 필터링 하지 않고
+ # 응답 헤더의 값으로 포함시켜 회신한다
+ ......
+ res = HttpResponse()
+ res['Content-Type'] = content_type
+ return res","from django.http import HttpResponse
+def route(request):
+ content_type = request.POST.get('content-type')
+# 응답헤더에 포함될 수 있는 외부 입력값 내의 개행 문자를 제거한다
+ content_type = content_type.replace('\r', '')
+ content_type = content_type.replace('\n', '')
+ ......
+ res = HttpResponse()
+ res['Content-Type'] = content_type
+ return res"
+Python,입력데이터 검증 및 표현,정수형 오버플로우,"정수형 변수에 저장된 값이 허용된 정수 값 범위를 벗어나 프로그램이 예기치 않게 동작 가능한
+보안약점","import numpy as np
+def handle_data(number, pow):
+ res = np.power(number, pow, dtype=np.int64)
+ # 64비트를 넘어서는 숫자와 지수가 입력될 경우 오버플로우가 발생해 결과값이 0이 된다
+ return res","import numpy as np
+MAX_NUMBER = np.iinfo(np.int64).max
+MIN_NUMBER = np.iinfo(np.int64).min
+def handle_data(number, pow):
+ calculated = number ** pow
+ # 파이썬 기본 자료형으로 큰 수를 계산한 후 이를 검사해 오버플로우 탐지
+ if calculated > MAX_NUMBER or calculated < MIN_NUMBER:
+ # 오버플로우 탐지 시 비정상 종료를 나타내는 –1 값 반환
+ return –1
+ res = np.power(number, pow, dtype=np.int64)
+ return res"
+Python,입력데이터 검증 및 표현,보안기능 결정에 사용되는 부적절한 입력값,"보안기능(인증, 권한부여 등) 결정에 검증되지 않은 외부 입력값을 허용하여 보안기능을 우회하는
+보안약점","from django.shortcuts import render
+def init_password(request):
+ # 쿠키에서 권한 정보를 가져 온다
+ role = request.COOKIE['role']
+ request_id = request.POST.get('user_id', '')
+ request_mail = request.POST.get('user_email','')
+ # 쿠키에서 가져온 권한이 관리자인지 비교
+ if role == 'admin':
+ # 사용자의 패스워드 초기화 및 메일 발송 처리
+ password_init_and_sendmail(request_id, request_mail)
+ return render(request, '/success.html')
+ else:
+ return render(request, '/failed.html')","from django.shortcuts import render
+def init_password(request):
+ # 세션에서 권한 정보를 가져옴
+ role = request.session['role']
+ request_id = request.POST.get('user_id', '')
+ request_mail = request.POST.get('user_email','')
+ # 세션에서 가져온 권한이 관리자인지 비교
+ if role == ‘admin’:
+ # 사용자의 패스워드 초기화 및 메일 발송 처리
+ password_init_and_sendmail(request_id, request_mail)
+ return render(request, '/sucess.html')
+ else:
+ return render(request, '/failed.html')"
+Python,입력데이터 검증 및 표현,포맷 스트링 삽입,str.format등 포맷 스트링 제어함수에 검증되지 않은 외부 입력값을 허용하여 발생하는 보안약점* 포맷 스트링: 입·출력에서 형식이나 형태를 지정해주는 문자열,"from django.shortcuts import render
+AUTHENTICATE_KEY = 'Passw0rd' def make_user_message(request):
+ user_info = get_user_info(request.POST.get('user_id', ''))
+
+ format_string = request.POST.get('msg_format', '')
+ # 내부의 민감한 정보가 외부로 노출될 수 있다.
+ # 사용자가 입력한 문자열을 포맷 문자열로 사용하고 있어 안전하지 않다
+ message = format_string.format(user=user_info)
+
+ return render(request, '/user_page.html', {'message':message})","from django.shortcuts import render
+AUTHENTICATE_KEY = 'Passw0rd' def make_user_message(request):
+ user_info = get_user_info(request.POST.get('user_id', ''))
+
+ # 사용자가 입력한 문자열을 포맷 문자열로 사용하지 않아 안전하다
+ message = 'user name is {}'.format(user_info.name)
+return render(request, '/user_page.html', {'message':message})"
+Python,보안기능,적절한 인증 없는 중요 기능 허용,"중요정보(금융정보, 개인정보, 인증정보 등)를 적절한 인증없이 열람(또는 변경) 가능한
+보안약점","from django.shortcuts import render
+from re import escape
+import hashlib
+def change_password(request):
+ new_pwd = request.POST.get('new_password','')
+ # 로그인한 사용자 정보
+ user = '%s' % escape(request.session['userid'])
+ # 현재 password와 일치 여부를 확인하지 않고 수정함
+ sha = hashlib.sha256(new_pwd.encode())
+ update_password_from_db(user, sha.hexdigest())
+ return render(request, '/success.html')","from django.contrib.auth.decorators import login_required
+from django.shortcuts import render
+from re import escape
+import hashlib
+
+# login_required decorator를 사용해 login된 사용자만 접근하도록 처리
+@login_required
+def change_password(request):
+   new_pwd = request.POST.get('new_password','')
+   crnt_pwd = request.POST.get('current_password','')
+   # 로그인한 사용자 정보를 세션에서 가져온다.
+   user = '%s' % escape(request.session['userid'])
+   crnt_h = hashlib.sha256(crnt_pwd.encode())
+   h_pwd = crnt_h.hexdigest()
+
+# DB에서 기존 사용자의 Hash된 패스워드 가져오기
+   old_pwd = get_password_from_db(user)
+   
+# 패스워드를 변경하기 전 사용자에 대한 재인증을 수행한다.
+   if old_pwd == h_pwd:
+    new_h = hashlib.sha256(new_pwd.encode())
+    update_password_from_db(user, new_h.hexdigest())
+    return render(request, '/success.html')
+   else:
+    return render(request, 'failed.html', {'error': '패스워드가 일치하지 않습니다'})"
+Python,보안기능,부적절한 인가,중요자원에 접근할 때 적절한 제어가 없어 비인가자의 접근이 가능한 보안약점,"from django.shortcuts import render
+from .model import Content
+def delete_content(request):
+ action = request.POST.get('action', '')
+ content_id = request.POST.get('content_id', '')
+ # 작업 요청을 하는 사용자의 권한 확인 없이 delete를 수행
+ if action is not None and action == ""delete"":
+ Content.objects.filter(id=content_id).delete()
+ return render(request, '/success.html')
+ else:
+ return render(request, '/error.html', {'error':'접근 권한이 없습니다.'})","from django.contrib.auth.decorators import login_required, permission_required
+from django.shortcuts import render
+from .model import Content
+@login_required
+# 해당 기능을 수행할 권한이 있는지 확인
+@permission_required('content.delete', raise_exception=True)
+def delete_content(request):
+ action = request.POST.get('action', '')
+ content_id = request.POST.get('content_id', '')
+ if action is not None and action == ""delete"":
+ Content.objects.filter(id=content_id).delete()
+ return render(request, '/success.html')
+ else:
+ return render(request, '/error.html', {'error':'삭제 실패'})"
+Python,보안기능,중요한 자원에 대한 잘못된 권한 설정,중요자원에 적절한 접근 권한을 부여하지 않아 중요정보가 노출·수정 가능한 보안약점,"import os
+def write_file():
+ # 모든 사용자가 읽기, 쓰기, 실행 권한을 가지게 된다.
+ os.chmod('/root/system_config', 0o777)
+ with open(""/root/system_config"", 'w') as f:
+ f.write(""your config is broken"")","import os
+def write_file():
+ # 소유자 외에는 아무런 권한을 주지 않음.
+ os.chmod('/root/system_config', 0o700)
+ with open(""/root/system_config"", ‘'w') as f:
+ f.write(""your config is broken"")"
+Python,보안기능,취약한 암호화 알고리즘 사용,"중요정보 (금융정보, 개인정보, 인증정보 등)의 기밀성을 보장할 수 없는 취약한 암호화 알고리즘을 사용하여 정보가 노출 가능한 보안약점","import base64
+from Crypto.Cipher import DES
+from Crypto.Util.Padding import pad
+def get_enc_text(plain_text, key):
+ # 취약함 암호화 알고리즘인 DES를 사용하여 안전하지 않음
+ cipher_des = DES.new(key, DES.MODE_ECB)
+ encrypted_data = base64.b64encode(cipher_aes.encrypt(pad(plain_text, 32)))
+ return encrypted_data.decode('ASCII')","import base64
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad
+def get_enc_text(plain_text, key, iv):
+ # 안전한 알고리즘인 AES 를 사용하여 안전함.
+ cipher_aes = AES.new(key, AES.MODE_CBC, iv)
+ encrypted_data = base64.b64encode(cipher_aes.encrypt(pad(plain_text, 32)))
+ return encrypted_data.decode('ASCII')"
+Python,보안기능,취약한 암호화 알고리즘 사용,"중요정보 (금융정보, 개인정보, 인증정보 등)의 기밀성을 보장할 수 없는 취약한 암호화 알고리즘을 사용하여 정보가 노출 가능한 보안약점","import hashlib
+def make_md5(plain_text):
+ # 취약한 md5 해시함수 사용
+ hash_text = hashlib.md5(plain_text.encode('utf-8')).hexdigest()
+ return hash_text","import hashlib
+def make_sha256(plain_text):
+ # 안전한 sha-256 해시함수 사용
+ hash_text = hashlib.sha256(plain_text.encode('utf-8')).hexdigest()
+ return hash_text"
+Python,보안기능,암호화되지 않은 중요정보,"중요정보(패스워드, 개인정보 등) 전송 시 암호화 또는 안전한 통신채널을 이용하지 않거나, 저장 시 암호화 하지 않아 정보가 노출 가능한 보안약점","def update_pass(dbconn, password, user_id):
+ curs = dbconn.cursor()
+ # 암호화되지 않은 패스워드를 DB에 저장
+ curs.execute(
+ 'UPDATE USERS SET PASSWORD=%s WHERE USER_ID=%s',
+ password,
+ user_id
+ )
+ dbconn.commit()","from Crypto.Hash import SHA256
+def update_pass(dbconn, password, user_id, salt):
+ # 단방향 암호화를 이용하여 패스워드를 암호화
+ hash_obj = SHA256.new()
+ hash_obj.update(bytes(password + salt, 'utf-8'))
+ hash_pwd = hash_obj.hexdigest()
+ curs = dbconn.cursor()
+ curs.execute(
+ 'UPDATE USERS SET PASSWORD=%s WHERE USER_ID=%s',
+ (hash_pwd, user_id)
+ )
+ dbconn.commit()"
+Python,보안기능,암호화되지 않은 중요정보,"중요정보(패스워드, 개인정보 등) 전송 시 암호화 또는 안전한 통신채널을 이용하지 않거나, 저장 시 암호화 하지 않아 정보가 노출 가능한 보안약점","import socket
+HOST = '127.0.0.1'
+PORT = 65434
+def send_password(password):
+ ......
+ with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+ s.connect((HOST, PORT))
+ # 패스워드를 암호화 하지 않고 전송하여 안전하지 않다.
+ s.sendall(password.encode('utf-8'))
+ data = s.recv(1024)
+ ....... ","import socket
+import os
+from Crypto.Cipher import AES
+HOST = '127.0.0.1'
+PORT = 65434
+def send_password(password):
+# 문자열로 저장되어 있는 블록키를 로드
+ block_key = os.environ.get('BLOCK_KEY')
+ aes = AEScipher(block_key)
+ # 패스워드 등 중요 정보는 암호화하여 전송하는 것이 안전하다
+ enc_passowrd = aes.encrypt(passowrd)
+ with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+ s.connect((HOST, PORT))
+ s.sendall(enc_passowrd.encode('utf-8'))
+ data = s.recv(1024)
+ .......
+class AEScipher:
+ BS = AES.block_size
+ def __init__(self, s_key):
+ self.s_key = hashlib.sha256(s_key.encode(""utf-8"")).digest()
+ def pad(self, m):
+ return m + bytes([self.BS - len(m) % self.BS] * (self.BS - len(m) % self.BS))
+ def encrypt(self, plain):
+ plain = self.pad(plain.encode())
+ iv = Random.new().read(AES.block_size)
+ cipher = AES.new(self.s_key, AES.MODE_CBC, iv)
+ return base64.b64encode(iv + cipher.encrypt(plain)).decode(""utf-8"")
+......."
+Python,보안기능,하드코드된 중요정보,"소스코드에 중요정보(패스워드, 암호화키 등)를 직접 코딩하여 소스코드 유출 시 중요정보가노출되고 주기적 변경이 어려운 보안약점","import pymysql
+def query_execute(query):
+ # user, passwd가 소스코드에 평문으로 하드코딩되어 있음
+ dbconn = pymysql.connect(
+ host='127.0.0.1',
+ port='1234',
+ user='root',
+ passwd='1234',
+ db='mydb',
+ charset='utf8',
+ )
+curs = dbconn.cursor()
+curs.execute(query)
+dbconn.commit()
+dbconn.close()","import pymysql
+import json
+def query_execute(query, config_path): with open(config_path, 'r') as config:
+ # 설정 파일에서 user, passwd를 가져와 사용
+dbconf = json.load(fp=config)
+ # 암호화되어 있는 블록 암호화 키를 복호화 해서 가져오는
+# 사용자 정의 함수
+blockKey = get_decrypt_key(dbconf['blockKey'])
+# 설정 파일에 암호화되어 있는 값을 가져와 복호화한 후에 사용
+dbUser = decrypt(blockKey, dbconf['user'])        dbPasswd = decrypt(blockKey, dbconf['passwd'])
+ dbconn = pymysql.connect(
+ host=dbconf['host']
+ port=dbconf['port'],
+ user=dbUser,
+ passwd=dbPasswd,
+ db=dbconf['db_name'],
+ charset='utf8',
+ )
+curs = dbconn.cursor()
+curs.execute(query)
+dbconn.commit()
+dbconn.close()"
+Python,보안기능,충분하지 않은 키 길이 사용,암호화 등에 사용되는 키의 길이가 충분하지 않아 데이터의 기밀성·무결성을 보장할 수 없는보안약점,"from Crypto.PublicKey import RSA, DSA, ECC
+from tinyec import registry
+import secrets
+def make_rsa_key_pair():
+ # RSA키 길이를 2048 비트 이하로 설정하는 경우 안전하지 않음
+ private_key = RSA.generate(1024)
+ public_key = private_key.publickey()
+def make_ecc():
+ # ECC의 키 길이를 224비트 이하로 설정하는 경우 안전하지 않음
+ ecc_curve = registry.get_curve('secp192r1')
+ private_key = secrets.randbelow(ecc_curve.field.n)
+ public_key = private_key * ecc_curve.g","from Crypto.PublicKey import RSA, DSA, ECC
+from tinyec import registry
+import secrets
+def make_rsa_key_pair():
+# RSA 키 길이를 2048 비트 이상으로 길게 설정
+private_key = RSA.generate(2048)
+public_key = private_key.publickey()
+def make_ecc():
+ # ECC 키 길이를 224 비트 이상으로 설정
+ ecc_curve = registry.get_curve('secp224r1')
+ private_key = secrets.randbelow(ecc_curve.field.n)
+ public_key = private_key * ecc_curve.g"
+Python,보안기능,적절하지 않은 난수 값 사용,"사용한 난수가 예측 가능하여, 공격자가 다음 난수를 예상해서 시스템을 공격 가능한 보안약점","import random
+def get_otp_number():
+ random_str = '' # 시스템 현재 시간 값을 시드로 사용하고 있으며, 주요 보안 기능을 위한
+ # 난수로 안전하지 않다
+ for i in range(6):
+ random_str += str(random.randrange(10))
+ return random_str","import secrets
+def get_otp_number():
+ random_str = ''
+ # 보안기능에 적합한 난수 생성용 secrets 라이브러리 사용
+ for i in range(6):
+ random_str += str(secrets.randbelow(10))
+ return random_str"
+Python,보안기능,적절하지 않은 난수 값 사용,"사용한 난수가 예측 가능하여, 공격자가 다음 난수를 예상해서 시스템을 공격 가능한 보안약점","import random
+import string
+def generate_session_key():
+ RANDOM_STRING_CHARS = string.ascii_letters + string.digits
+ # random 라이브러리를 보안 기능에 사용하면 위험하다
+ return “”.join(random.choice(RANDOM_STRING_CHARS) for i in range(32))","import secrets
+import string
+def generate_session_key():
+ RANDOM_STRING_CHARS = string.ascii_letters+string.digits
+ # 보안 기능과 관련된 난수는 secrets 라이브러리를 사용해야 안전하다
+ return “”.join(secrets.choice(RANDOM_STRING_CHARS) for i in range(32))"
+Python,보안기능,취약한 패스워드 허용,"패스워드 조합규칙(영문, 숫자, 특수문자 등) 미흡 및 길이가 충분하지 않아 패스워드가
+노출 가능한 보안약점","from flask import request, redirect
+from Models import User
+from Models import db
+@app.route('/register', methods=['POST'])
+def register():
+ userid = request.form.get('userid')
+ password = request.form.get('password')
+ confirm_password = request.form.get('confirm_password')
+ if password != confirm_password:
+ return make_response(""패스워드가 일치하지 않습니다"", 400)
+ else:
+ usertable = User()
+ usertable.userid = userid
+ usertable.password = password
+ # 패스워드 생성 규칙을 확인하지 않고 회원 가입
+ db.session.add(usertable)
+ db.session.commit()
+ return make_response(""회원가입 성공"", 200)","from flask import request, redirect
+from Models import User
+from Models import db
+import re
+@app.route('/register', methods=['POST'])
+def register():
+ userid = request.form.get('userid')
+ password = request.form.get('password')
+ confirm_password = request.form.get('confirm_password')
+ if password != confirm_password:
+ return make_response(""패스워드가 일치하지 않습니다."", 400)
+
+ if not check_password(password):
+ return make_response(""패스워드 조합규칙에 맞지 않습니다."", 400)
+ else:
+ usertable = User()
+ usertable.userid = userid
+ usertable.password = password
+
+ db.session.add(usertable)
+ db.session.commit()
+ return make_response(""회원가입 성공"", 200)
+def check_password(password):
+ # 3종 이상 문자로 구성된 8자리 이상 패스워드 검사 정규식 적용
+ PT1 = re.compile('^(?=.*[A-Z])(?=.*[a-z])[A-Za-z\d!@#$%^&*]{8,}$')
+ PT2 = re.compile('^(?=.*[A-Z])(?=.*\d)[A-Za-z\d!@#$%^&*]{8,}$')
+ PT3 = re.compile('^(?=.*[A-Z])(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$')
+ PT4 = re.compile('^(?=.*[a-z])(?=.*\d)[A-Za-z\d!@#$%^&*]{8,}$')
+ PT5 = re.compile('^(?=.*[a-z])(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$')
+ PT6 = re.compile('^(?=.*\d)(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$')
+ # 문자 구성 상관없이 10자리 이상 패스워드 검사 정규식
+ PT7 = re.compile('^[A-Za-z\d!@#$%^&*]{10,}$')
+ for pattern in [PT1, PT2, PT3, PT4, PT5, PT6, PT7]:
+ if pattern.match(password):
+ return True
+ return False"
+Python,보안기능,취약한 패스워드 허용,"패스워드 조합규칙(영문, 숫자, 특수문자 등) 미흡 및 길이가 충분하지 않아 패스워드가
+노출 가능한 보안약점","from django.shortcuts import render, redirect
+from django.http import HttpResponse
+from .models import User
+from django.views.decorators.http import require_POST
+
+@require_POST
+def register(request):
+    userid = request.POST.get('userid')
+    password = request.POST.get('password')
+    confirm_password = request.POST.get('confirm_password')
+    
+    if password != confirm_password:
+        return HttpResponse(""패스워드가 일치하지 않습니다"", status=400)
+    else:
+        usertable = User()
+        usertable.userid = userid
+        usertable.password = password
+        # 패스워드 생성 규칙을 확인하지 않고 회원 가입
+        usertable.save()
+        return HttpResponse(""회원가입 성공"", status=200)","import re
+from django.core.exceptions import ValidationError
+from django.utils.translation import ugettext as _ class CustomValidator(object):
+ def validate(self, password, user=None):
+ # 3종 이상 문자로 구성된 8자리 이상 패스워드 검사 정규식
+ PT1 = re.compile('^(?=.*[A-Z])(?=.*[a-z])[A-Za-z\d!@#$%^&*]{8,}$')
+ PT2 = re.compile('^(?=.*[A-Z])(?=.*\d)[A-Za-z\d$@$!%*?&]{8,}$')
+ PT3 = re.compile('^(?=.*[A-Z])(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$')
+ PT4 = re.compile('^(?=.*[a-z])(?=.*\d)[A-Za-z\d!@#$%^&*]{8,}$')
+ PT5 = re.compile('^(?=.*[a-z])(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$')
+ PT6 = re.compile('^(?=.*\d)(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$')
+ # 문자 구성 상관없이 10자리 이상 패스워드 검사 정규식
+ PT7 = re.compile('^[A-Za-z\d!@#$%^&*]{10,}$')
+ for pattern in [PT1, PT2, PT3, PT4, PT5, PT6, PT7]:
+ if pattern.match(password):
+ return None
+ raise ValidationError(
+ _(""패스워드 조합규칙에 적합하지 않습니다..""),
+ code='improper_password',
+ )
+ def get_help_text(self):
+ return _(
+ ""패스워드는 영문 대문자, 소문자, 숫자, 특수문자 조합 중 2가지 이상 8자리이거나 문자 구성
+ 상관없이 10자리 이상이어야 합니다.""
+ )"
+Python,보안기능,부적절한 전자서명 확인,"프로그램, 라이브러리, 코드의 전자서명에 대한 유효성 검증이 적절하지 않아 공격자의
+악의적인 코드가 실행 가능한 보안약점","import base64
+from Crypto.PublicKey import RSA
+from Crypto.Hash import SHA256
+from Crypto.Signature import PKCS1_v1_5 as SIGNATURE_PKCS1_v1_5
+from Crypto.Cipher import PKCS1_v1_5, AES
+from Crypto.Util.Padding import unpad
+... def verify_data(request):
+ # 클라이언트로부터 전달받은 데이터(전자서명을 수신 처리 하지 않음)
+ encrypted_code = request.POST.get(""encrypted_msg"", """") # 암호화된 파이썬 코드
+ # 서버의 대칭키 로드 (송수신측이 대칭키를 이미 공유했다고 가정)
+ with open(f""{PATH}/keys/secret_key.out"", ""rb"") as f:
+ secret_key = f.read()
+ # 대칭키로 클라이언트가 전달한 파이썬 코드 복호화
+ # (decrypt_with_symmetric_key 함수는 임의의 함수명으로 세부적인 복호화 과정은 생략함)
+ origin_python_code = decrypt_with_symmetric_key(secret_key, encrypted_code)
+ # 클라이언트로부터 전달 받은 파이썬 코드 실행
+ eval(origin_python_code)
+ return render(
+ request,
+ ""/verify_success.html"",
+ {""result"": ""파이썬 코드를 실행했습니다.""},
+ )","# 전자서명 검증에 사용한 코드는 의존한 파이썬 패키지 및 송신측 언어에 따라
+# 달라질 수 있으며, 사전에 공유한 공개키로 복호화한 전자서명과 원본 데이터 해시값의
+# 일치 여부를 검사하는 코드를 포함
+def verify_digit_signature (
+ origin_data: bytes, origin_signature: bytes, client_pub_key: str ) -> bool:
+ hashed_data = SHA256.new(origin_data)
+ signer = SIGNATURE_PKCS1_v1_5.new(RSA.importKey(client_pub_key))
+ return signer.verify(hashed_data, base64.b64decode(origin_signature))
+def verify_data(request):
+ # 클라이언트로부터 전달받은 데이터
+ encrypted_code = request.POST.get(""encrypted_msg"", """") # 암호화된 파이썬 코드
+ encrypted_sig = request.POST.get(""encrypted_sig"", """") # 암호화된 전자서명
+
+ # 서버의 대칭(비밀)키 및 공개키 로드
+ with open(f""/keys/secret_key.out"", ""rb"") as f:
+ secret_key = f.read()
+ with open(f""/keys/public_key.out"", ""rb"") as f:
+ public_key = f.read()
+ # 대칭키로 파이썬 코드 및 전자서명 복호화
+ origin_python_code = decrypt_with_symmetric_key(symmetric_key, encrypted_code)
+ origin_signature = decrypt_with_symmetric_key(symmetric_key, encrypted_sig)
+ # 클라이언트의 공개키를 통해 파이썬 코드(원문)와 전자서명을 검증
+ verify_result = verify_digit_signature(origin_python_code, origin_signature, client_pub_key)
+ # 전자서명 검증을 통과했다면 파이썬 코드 실행
+ if verify_result:
+ eval(origin_python_code)
+ return render(request, ""/verify_success.html"",
+ {""result"": ""전자서명 검증 통과 및 파이썬 코드를 실행했습니다.""},
+ )
+ else:
+ return render(request, ""/verify_failed.html"",
+ {""result"": ""전자서명 또는 파이썬 코드가 위/변조되었습니다.""},
+ )"
+Python,보안기능,부적절한 인증서 유효성 검증,인증서에 대한 유효성 검증이 적절하지 않아 발생하는 보안약점,"import os
+import socket
+import ssl
+HOST, PORT = ""127.0.0.1"", 7917
+def connect_with_server():
+ with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:
+ # 보안 정책 수동 설정
+ context = ssl.SSLContext()
+ # SSLContext 생성자를 직접 호출할 때, CERT_NONE이 기본값
+ # 상대방을 인증하지 않기 때문에 통신하고자하는 서버의 신뢰성을 보장할 수 없음
+ context.verify_mode = ssl.CERT_NONE
+ with context.wrap_socket(sock) as ssock:
+ try:
+ ssock.connect((HOST, PORT))
+ ssock.send(""Hello I'm a vulnerable client :)"".encode(""utf-8""))
+ data = ssock.recv(1024).decode(""utf-8"")
+ print(f"">> server from ({HOST}, {PORT}): {data}\n"")
+ finally:
+ ssock.close()","import os
+import socket
+import ssl
+CURRENT_PATH = os.getcwd()
+HOST_NAME = ""test-server""
+HOST, PORT = ""127.0.0.1"", 7917
+SERVER_CA_PEM = f""{CURRENT_PATH}/rsa_server/CA.pem"" # 서버로부터 전달받은 CA 인증서
+def connect_with_server():
+ with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:
+ # PROTOCOL_TLS_CLIENT 프로토콜을 추가하여 인증서 유효성 검사와 호스트 이름 확인을 위한
+ # context를 구성. verify_mode가 CERT_REQUIRED로 설정됨
+ # check_hostname이 True로 설정됨
+ context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+ # 서버로부터 전달받은 CA 인증서를 context에 로드
+ # CERT_REQUIRED로 인해 필수
+ context.load_verify_locations(SERVER_CA_PEM)
+ # 호스트 이름(HOST_NAME)이 일치하지 않으면 통신 불가
+ # 생성된 소켓과 context wrapping 시 server_hostname이 실제 서버에서
+ # 등록(server.csr)한 호스트 명과 일치해야 함
+ with context.wrap_socket(sock, server_hostname=HOST_NAME) as ssock:
+ try:
+ ssock.connect((HOST, PORT))
+ ssock.send(""Hello I'm a patched client :)"".encode(""utf-8""))
+ data = ssock.recv(1024).decode(""utf-8"")
+ print(f"">> server from ({HOST}, {PORT}): {data}\n"")
+ finally:
+ ssock.close()"
+Python,보안기능,사용자 하드디스크에 저장되는 쿠키를 통한 정보 노출,"쿠키(세션 ID, 사용자 권한정보 등 중요정보)를 사용자 하드디스크에 저장하여 중요정보가
+노출 가능한 보안약점","from django.http import HttpResponse
+def remind_user_state(request):
+ res = HttpResponse()
+ # 쿠키의 만료시간을 1년으로 과도하게 길게 설정하고 있어 안전하지 않다
+ res.set_cookie('rememberme', 1, max_age=60*60*24*365)
+ return res","from django.http import HttpResponse
+def remind_user_state(request):
+ res = HttpResponse()
+ # 쿠키의 만료시간을 적절하게 부여하고 secure 및 httpOnly 옵션을 활성화 한다.
+ res.set_cookie('rememberme', 1, max_age=60*60, secure=True, httponly=True)
+ return res"
+Python,보안기능,사용자 하드디스크에 저장되는 쿠키를 통한 정보 노출,"쿠키(세션 ID, 사용자 권한정보 등 중요정보)를 사용자 하드디스크에 저장하여 중요정보가
+노출 가능한 보안약점","from django.http import HttpResponse
+def remind_user_state(request):
+ res = HttpResponse()
+ # 쿠키의 만료시간을 1년으로 과도하게 길게 설정하고 있어 안전하지 않다
+ res.set_cookie('rememberme', 1, max_age=60*60*24*366)
+ return res","from django.http import HttpResponse
+from django.conf.global_settings import (
+ SESSION_COOKIE_AGE,
+ SESSION_COOKIE_HTTPONLY,
+ SESSION_COOKIE_HTTPONLY,
+)
+"""""" # settings.py
+SESSION_COOKIE_AGE = 60 * 60 * 24 * 14
+SESSION_COOKIE_HTTPONLY = True
+SESSION_COOKIE_SECURE = True
+"""""" def remind_user_state(request):
+ res = HttpResponse()
+ # 서버 세팅(setting.py)에서 default로 쿠키 옵션을 설정한 상태
+ res.set_cookie(
+ ""rememerme"",
+ 1,
+ max_age=SESSION_COOKIE_AGE,
+ secure=SESSION_COOKIE_HTTPONLY,
+ httponly=SESSION_COOKIE_HTTPONLY,
+ )
+ return res"
+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 질의문을 생성할 때 검증되지 않은 외부 입력 값을 허용하여 악의적인 질의문이 실행가능한 보안약점,"<?xml version=""1.0"" encoding=""UTF-8"" ?>
+<!DOCTYPE mapper PUBLIC ""-//mybatis.org//DTD Mapper 3.0//EN“
+ ""http://mybatis.org/dtd/mybatis-3-mapper.dtd"">
+......
+<select id=""boardSearch"" parameterType=""map"" resultType=""BoardDto"">
+//$기호를 사용하는 경우 외부에서 입력된 keyword값을 문자열에 결합한 형태로 쿼리에 반영되므로
+안전하지 않다.
+ select * from tbl_board where title like '%$ {keyword }%' order by pos asc
+</select>","<?xml version=""1.0"" encoding=""UTF-8"" ?>
+<!DOCTYPE mapper PUBLIC ""-//mybatis.org//DTD Mapper 3.0//EN""
+ ""http://mybatis.org/dtd/mybatis-3-mapper.dtd"">
+......
+<select id=""boardSearch"" parameterType=""map"" resultType=""BoardDto"">
+//$ 대신 #기호를 사용하여 변수가 쿼리맵에 바인딩 될 수 있도록 수정하는 것이 안전하다.
+ select * from tbl_board where title like '%'||# {keyword }||'%' order by pos asc
+</select>"
+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,입력데이터 검증 및 표현,코드삽입,프로세스가 외부 입력 값을 코드(명령어)로 해석·실행할 수 있고 프로세스에 검증되지 않은 외부 입력 값을 허용한 경우 악의적인 코드가 실행 가능한 보안약점,"<body>
+ <%
+String name = request.getparameter(""name"");
+ %>
+ ...
+ <script>
+ // 외부 입력값인 name을 javascript new Function()을 이용하여 문자열을 함수로 실행하고 있다.
+(new Function(<%=name%>))();
+ </script>
+ </body>","''
+@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(&regex, “.*￦￦.￦￦..*”, 0);
+ // 경로 조작 가능성 있는 문자열 탐지
+ ret = regexec(&regex, 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}
+<script type=""text/javascript"">
+//외부 입력값에 대하여 검증 없이 브라우저에서 실행되는 경우 서버를 거치지 않는 공격스크립트가
+포함된 URL을 생성 할 수 있어 안전하지 않다. (DOM 기반 XSS)
+document.write(""keyword:"" + <%=keyword%>);
+</script>","<% String keyword = request.getParameter(""keyword""); %>
+// 방법1. 입력값에 대하여 스크립트 공격가능성이 있는 문자열을 치환한다.
+keyword = keyword.replaceAll(""&"", ""&amp;"");
+keyword = keyword.replaceAll(""<"", ""&lt;"");
+keyword = keyword.replaceAll("">"", ""&gt;"");
+keyword = keyword.replaceAll(""￦"""", ""&quot;"");
+keyword = keyword.replaceAll(""'"", ""&#x27;"");
+keyword = keyword.replaceAll(""/"""", ""&#x2F;"");
+keyword = keyword.replaceAll(""("", ""&#x28;"");
+keyword = keyword.replaceAll("")"", ""&#x29;"");
+검색어 : <%=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:out value=""$ {m.content}""/>
+
+<script type=""text/javascript"">
+//방법3. 잘 만들어진 외부 라이브러리를 활용(NAVER Lucy-XSS-Filter, OWASP ESAPI,
+OWASP Java-Encoder-Project)
+document.write(""keyword:""+
+ <%=Encoder.encodeForJS(Encoder.encodeForHTML(keyword))%>);
+</script>"
+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<br/>”, data);
+ fprintf(cgiOut, “</body></html>￦n”);
+ return 0;
+}","cgiFromString(“user input”, data, sizeof(data));
+// data에 위험한 문자열을 검사하는 코드를 추가한다.
+if(strchr(p, ‘<’)) return;
+if(strchr(p, ‘>’)) return;
+…
+fprintf(cgiOut, “Print user input = %s<br/>”, data);
+fprintf(cgiOut, “</body></html>￦n”);"
+JAVA,입력데이터 검증 및 표현,운영체제 명령어 삽입,운영체제 명령어를 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 명령어가 실행 가능한 보안약점,"public static void main(String args[]) throws IOException {
+    // 해당 프로그램에서 실행할 프로그램을 제한하고 있지 않아 파라미터로 전달되는 모든 프로그램이
+    실행될 수 있다.
+     String cmd = args[0];
+     Process ps = null;
+     try {
+     ps = Runtime.getRuntime().exec(cmd);
+     …","public static void main(String args[]) throws IOException {
+    // 해당 어플리케이션에서 실행할 수 있는 프로그램을 노트패드와 계산기로 제한하고 있다.
+     List<String> allowedCommands = new ArrayList<String>(); “
+     allowedCommands.add(""notepad""); allowedCommands.add(""calc"");
+     String cmd = args[0];
+     if (!allowedCommands.contains(cmd)) {
+     System.err.println(""허용되지 않은 명령어입니다."");
+     return;
+    }
+    Process ps = null; try {
+    ps = Runtime.getRuntime().exec(cmd);
+    ......"
+JAVA,입력데이터 검증 및 표현,운영체제 명령어 삽입,운영체제 명령어를 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 명령어가 실행 가능한 보안약점,"//외부로부터 입력받은 값을 검증 없이 사용할 경우 안전하지 않다.
+String date = request.getParameter(""date"");
+String command = new String(""cmd.exe /c backuplog.bat"");
+Runtime.getRuntime().exec(command + date);","String date = request.getParameter(""date"");
+String command = new String(""cmd.exe /c backuplog.bat"");
+//외부로부터 입력 받은 값을 필터링으로 우회문자를 제거하여 사용한다.
+date = date.replaceAll(""|"","""");
+date = date.replaceAll("";"","""");
+date = date.replaceAll(""&"","""");
+date = date.replaceAll("":"","""");
+date = date.replaceAll("">"",""""); Runtime.getRuntime().exec(command + date);"
+C#,입력데이터 검증 및 표현,운영체제 명령어 삽입,운영체제 명령어를 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 명령어가 실행 가능한 보안약점,"//외부 입력값이 프로세스가 실행할 파일 이름을 지정하고 있다.
+string fileName = PgmTextBox.Text;
+ProcessStartInfo proStartInfo = new ProcessStartInfo();
+proStartInfo.FileName = fileName;
+Process.Start(proStartInfo);","string fileName = PgmTextBox.Text;
+//외부 입력값에 대해 정규식 등을 이용하여 검증해야 한다.
+ if (Regex.IsMatch(fileName, ""properRegexHere""))
+{
+ProcessStartInfo proStartInfo = new ProcessStartInfo();
+proStartInfo.FileName = fileName;
+Process.Start(proStartInfo);
+}"
+C,입력데이터 검증 및 표현,운영체제 명령어 삽입,운영체제 명령어를 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 명령어가 실행 가능한 보안약점,"int main(int argc, char* argv[]) {
+ char cmd[CMD_LENGTH];
+ if (argc < 1 ) {
+ // error
+}
+// 외부 입력값으로 커맨드를 직접 수행
+cmd_data = argv[1];
+snprintf(cmd, CMD_LENGTH, “cat %s”, cmd_data);
+system(cmd);
+……
+}","int main(int argc, char* argv[]) {
+ char cmd[CMD_LENGTH]; int len = 0;
+ if (argc < 1 ) {
+ // error
+ }
+ // 외부 입력값으로 커맨드를 직접 수행 cmd_data = argv[1];
+ len = strlen(cmd_data);
+for (int i = 0; I < len; i++) {
+ if (cmd_data[i] == ‘|’ || cmd_data[i] == ‘&’ ||
+ cmd_data[i] == ‘;’ || cmd_data[i] == ‘:’ || cmd_data[i] == ‘>’) {
+ // 멀티라인을 지원하는 특수문자나 파일 리다이렉트 특수문자가 존재하여
+// 안전하지 않음
+ return -1;
+ }
+}
+ snprintf(cmd, CMD_LENGTH, “cat %s”, cmd_data);
+ system(cmd);
+……
+}"
+JAVA,입력데이터 검증 및 표현,위험한 형식 파일 업로드,파일의 확장자 등 파일형식에 대한 검증없이 파일 업로드를 허용하여 공격이 가능한 보안약점,"MultipartRequest multi
+ = new MultipartRequest(request,savePath,sizeLimit,""euc-kr"",new
+DefaultFileRenamePolicy());
+......
+//업로드 되는 파일명을 검증없이 사용하고 있어 안전하지 않다.
+ String fileName = multi.getFilesystemName(""filename"");
+ ......
+ sql = "" INSERT INTO
+ board(email,r_num,w_date,pwd,content,re_step,re_num,filename) ""
+ + "" values ( ?, 0, sysdate(), ?, ?, ?, ?, ? ) "";
+ preparedStatement pstmt = con.prepareStatement(sql);
+pstmt.setString(1, stemail);
+pstmt.setString(2, stpwd);
+pstmt.setString(3, stcontent);
+pstmt.setString(4, stre_step);
+pstmt.setString(5, stre_num);
+pstmt.setString(6, fileName);
+pstmt.executeUpdate();
+Thumbnail.create(savePath+""/""+fileName, savePath+""/""+""s_""+fileName, 150);","MultipartRequest multi
+ = new MultipartRequest(request,savePath,sizeLimit,""euc-kr"",new
+ DefaultFileRenamePolicy());
+ ......
+ String fileName = multi.getFilesystemName(""filename"");
+ if (fileName != null) {
+//1.업로드 파일의 마지막 “.” 문자열의 기준으로 실제 확장자 여부를 확인하고, 대소문자 구별을
+해야한다.
+ String fileExt =
+ FileName.substring(fileName.lastIndexOf(""."")+1).toLowerCase();
+//2.되도록 화이트 리스트 방식으로 허용되는 확장자로 업로드를 제한해야 안전하다.
+ if (!""gif"".equals(fileExt) && !""jpg"".equals(fileExt) && !""png"".equals(fileExt))
+{
+ alertMessage(""업로드 불가능한 파일입니다."");
+ return;
+ }
+}
+......
+ sql = "" INSERT INTO
+board(email,r_num,w_date,pwd,content,re_step,re_num,filename) ""
+ + "" values ( ?, 0, sysdate(), ?, ?, ?, ?, ? ) "";
+PreparedStatement pstmt = con.prepareStatement(sql);
+......
+ Thumbnail.create(savePath+""/""+fileName, savePath+""/""+""s_""+fileName, 150);"
+C#,입력데이터 검증 및 표현,위험한 형식 파일 업로드,파일의 확장자 등 파일형식에 대한 검증없이 파일 업로드를 허용하여 공격이 가능한 보안약점,"string fn = Path.GetFileName(FileUploadCtr.FileName);
+//업로드 하는 파일명을 검증없이 사용하고 있다.
+FileUploadCtr.SaveAs(fn);
+StatusLabel.Text = ""Upload status: File uploaed!"";","//파일 타입과 크기를 제한합니다.
+if (FileUploadCtr.PostedFile.ContentType == ""image/jpeg”)
+{
+ if (FileUploadCtr.PostedFile.ContentLength < 102400)
+ {
+ string fn = Path.GetFileName(FileUploadCtr.FileName);
+ FileUploadCtr.SaveAs(Server.MapPath(""~/"") + fn);
+ StatusLabel.Text = ""Upload status: File uploaed!"";
+}
+else
+ StatusLabel.Text = ""Upload Status: The File has to be less than
+ 100 kb!"";
+}
+else
+StatusLabel.Text = ""Upload Status: Only JPEG files are accepted!"";"
+JAVA,입력데이터 검증 및 표현,신뢰되지 않는 URL 주소로 자동접속 연결,URL 링크 생성에 검증되지 않은 외부 입력값을 허용하여 악의적인 사이트로 자동 접속 가능한 보안약점,"String id = (String)session.getValue(""id"");
+String bn = request.getParameter(""gubun"");
+//외부로부터 입력받은 URL이 검증없이 다른 사이트로 이동이 가능하여 안전하지 않다.
+String rd = request.getParameter(""redirect"");
+if (id.length() > 0) {
+ String sql = ""select level from customer where customer_id = ? "";
+ conn = db.getConnection();
+ pstmt = conn.prepareStatement(sql);
+ pstmt.setString(1, id);
+ rs = pstmt.executeQuery();
+rs.next();
+if (""0"".equals(rs.getString(1)) && ""01AD"".equals(bn)) {
+ response.sendRedirect(rd);
+ return;
+}
+}","//이동 할 수 있는 URL범위를 제한하여 피싱 사이트 등으로 이동하지 못하도록 한다.
+String allowedUrl[] = { ""/main.do"", ""/login.jsp"", ""list.do"" };
+......
+String rd = request.getParameter(""redirect"");
+try {
+ rd = allowedUrl[Integer.parseInt(rd)];
+} catch(NumberFormatException e) {
+ return ""잘못된 접근입니다."";
+} catch(ArrayIndexOutOfBoundsException e) {
+ return ""잘못된 입력입니다."";
+}
+if (id.length() > 0) {
+......
+ if (""0"".equals(rs.getString(1)) && ""01AD"".equals(bn)) {
+ response.sendRedirect(rd);
+ return;
+}"
+C#,입력데이터 검증 및 표현,신뢰되지 않는 URL 주소로 자동접속 연결,URL 링크 생성에 검증되지 않은 외부 입력값을 허용하여 악의적인 사이트로 자동 접속 가능한 보안약점,"// 외부 입력값으로 받은 URL을 검증없이 연결하고 있다.
+string url = Request[""dest""];
+Response.Redirect(url);","public void AttackOpenRedirect()
+ {
+ String url = Request[""dest""];
+// 외부 입력값이 로컬 URL인지 확인한다. MVC 3 이상의 프레임워크를 사용할 경우,
+ System.Web.Mvc 에 정의되어있는 Url.isLocalUrl 을 바로 사용할 수 있다.
+ if(isLocalUri(url)) Response.Redirect(url);
+ }
+ private bool IsLocalUrl(string url)
+ {
+ if(string.IsNullOrEmpty(url))
+ {
+ return false;
+ }
+ Uri absoluteUri;
+ if(Uri.TryCreate(url, UriKind.Absolute, out absoluteUri))
+ {
+ return String.Equals(this.Request.Url.Host, absoluteUri.Host,
+ StringComparison.OrdinalIgnoreCase);
+ }
+ else
+ {
+ bool isLocal = !url.StartsWith(""http:"",
+ StringComparison.OrdinalIgnoreCase)
+ && !url.StartsWith(""https:"", StringComparison.OrdinalIgnoreCase)
+ && Uri.IsWellFormedUriString(url, UriKind.Relative);
+ return isLocal;
+ }
+}"
+JAVA,입력데이터 검증 및 표현,부적절한 XML 외부개체 참조,임의로 조작된 XML 외부개체에 대한 적절한 검증 없이 참조를 허용하여 공격이가능한 보안약점,"receivedXML
+<?xml version=""1.0"" encoding=""ISO-8859-1""?>
+<!DOCTYPE foo [
+<!ELEMENT foo ANY >
+<!ENTITY xxe SYSTEM ""file:///etc/passwd"" >]><foo>&xxe;</foo>
+
+public void unmarshal(File receivedXml)
+throws JAXBException, ParserConfigurationException, SAXException, IOException {
+JAXBContext jaxbContext = JAXBContext.newInstance( Student.class );
+Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
+// 입력받은 receivedXml 을 이용하여 Document를 생성한다.
+DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+dbf.setNamespaceAware(true);
+DocumentBuilder db = dbf.newDocumentBuilder();
+Document document = db.parse(receivedXml);
+// 외부 엔티티로 만들어진 document를 이용하여 마샬링을 수행하여 안전하지
+않다.
+Student employee = (Student) jaxbUnmarshaller.unmarshal( document );
+}"," DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+ // XML 파서가 doctype을 정의하지 못하도록 설정한다.
+ dbf.setFeature(""http://apache.org/xml/featuresdisallow-doctype-decl"", true);
+ // 외부 일반 엔티티를 포함하지 않도록 설정한다.
+ dbf.setFeature(""http://xml.org/sax/features/external-general-entities"", false);
+ // 외부 파라미터도 포함하지 않도록 설정한다.
+ dbf.setFeature(""http://xml.org/sax/features/external-parameter-entities"", false);
+ // 외부 DTD 비활성화한다.
+ dbf.setFeature(""http://apache.org/xml/features/nonvalidating/load-external-dtd"", false);
+ // XIncude를 사용하지 않는다.
+ dbf.setXIncludeAware(false);
+ // 생성된 파서가 엔티티 참조 노드를 확장하지 않도록 한다.
+ dbf.setExpandEntityReferences(false);
+ DocumentBuilder db = dbf.newDocumentBuilder();
+ Document document = db.parse(receivedXml);
+ Model model = (Model) u.unmarshal(document);"
+JAVA,입력데이터 검증 및 표현,부적절한 XML 외부개체 참조,임의로 조작된 XML 외부개체에 대한 적절한 검증 없이 참조를 허용하여 공격이가능한 보안약점,"secure.xml
+<?xml version=""1.0""?>
+<!DOCTYPE foo SYSTEM ""file:/dev/tty"">
+<foo>bar</foo>
+
+import javax.xml.parsers.SAXParsers;
+ import javax.xml.parsers.SAXParserFactory;
+ class XXE {
+ public static void main(String[] args)
+ throws FileNotFoundException, ParserConfigurationException, SAXException,
+IOException {
+    SAXParserFactory factory = SAXParserFactory.newInstance();
+ SAXParser saxParser = factory.newSAXParser();
+ // 외부개체 참조 제한 설정 없이 secure.xml 파일을 읽어서 파싱하여 안전하지 않다.
+ saxParser.parse(new FileInputStream(""secure.xml""), new DefaultHandler());
+ }
+}","value = libxml_disable_entity_loader(true);
+ $dom = new DOMDocument();
+ $dom -> loadXML($xml);
+ libxml_disable_entity_loader($value);"
+JAVA,입력데이터 검증 및 표현,XML 삽입,"XQuery, XPath 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이 실행가능한 보안약점"," // 외부 입력 값을 검증하지 않고 XQuery 표현식에 사용한다.
+String name = props.getProperty(""name"");
+ .......
+ // 외부 입력 값에 의해 쿼리 구조가 변경 되어 안전하지 않다.
+ String es = ""doc('users.xml')/userlist/user[uname='""+name+""']"";
+ XQPreparedExpression expr = conn.prepareExpression(es);
+XQResultSequence result = expr.executeQuery();","// blingString 함수로 쿼리 구조가 변경되는 것을 방지한다.
+String name = props.getProperty(""name"");
+...
+String es = ""doc('users.xml')/userlist/user[uname='$xname']"";
+XQPreparedExpression expr = conn.prepareExpression(es);
+expr.bindString(new QName(""xname""), name, null);
+XQResultSequence result = expr.executeQuery();
+..."
+C#,입력데이터 검증 및 표현,XML 삽입,"XQuery, XPath 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이 실행가능한 보안약점","//외부 입력 값으로 XQuery 문을 만든다.
+String squery =
+ ""for $user in doc(users.xml)//user[username='""
+ + UserTextBox.Text
+ + ""'and pass='""
+ + PwdTextBox.Text
+ + ""'] return $user"";
+ Processor processor = new Processor();
+ XQueryCompiler compiler = processor.NewXQueryCompiler();
+ XdmNode indoc = processor.NewDocumentBuilder().Build(new
+Uri(Server.MapPath(""users.xml"")));
+using (StreamReader query = new StreamReader(squery))
+{
+ XQueryCompiler compiler = processor.NewXQueryCompiler();
+ XQueryExecutable exp = compiler.Compile(query.ReadToEnd());
+ XQueryEvaluator eval = exp.Load();
+ eval.ContextItem = indoc;
+ Serializer qout = new Serializer();
+ qout.SetOutputProperty(Serializer.METHOD, ""xml"");
+ qout.SetOutputProperty(Serializer.DOCTYPE_PUBLIC, ""-//W3C//DTD
+XHTML 1.0 Strict//EN"");
+ qout.SetOutputProperty(Serializer.DOCTYPE_SYSTEM,
+""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"");
+ qout.SetOutputProperty(Serializer.INDENT, ""yes"");
+ qout.SetOutputProperty(Serializer.OMIT_XML_DECLARATION, ""no"");
+ qout.SetOutputWriter(Response.Output);
+//별다른 검증없이 XML 데이터에 접근한다.
+ eval.Run(qout);
+}","String squery =
+ ""for $user in doc(users.xml)//user[username='""
+ + UserTextBox.Text
+ + ""'and pass='""
+ + PwdTextBox.Text
+ + ""'] return $user"";
+ // 문자열 필터링으로 위험한 문자열을 제거한다.
+string validatedQuery = squery.Replace('/','*');
+ Processor processor = new Processor();
+ XQueryCompiler compiler = processor.NewXQueryCompiler();
+ XdmNode indoc = processor.NewDocumentBuilder().Build(new
+ Uri(Server.MapPath(""users.xml"")));
+ using (StreamReader query = new StreamReader(validatedQuery))
+  { // tainted value propagated
+ XQueryCompiler compiler = processor.NewXQueryCompiler();
+ XQueryExecutable exp = compiler.Compile(query.ReadToEnd()); //
+xquery created
+ XQueryEvaluator eval = exp.Load();
+ eval.ContextItem = indoc;
+ Serializer qout = new Serializer();
+ qout.SetOutputProperty(Serializer.METHOD, ""xml"");
+ qout.SetOutputProperty(Serializer.DOCTYPE_PUBLIC, ""-//W3C//DTD
+ XHTML 1.0 Strict//EN"");
+ qout.SetOutputProperty(Serializer.DOCTYPE_SYSTEM,
+ ""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"");
+ qout.SetOutputProperty(Serializer.INDENT, ""yes"");
+ qout.SetOutputProperty(Serializer.OMIT_XML_DECLARATION, ""no"");
+ qout.SetOutputWriter(Response.Output);
+ eval.Run(qout);
+ }"
+JAVA,입력데이터 검증 및 표현,XML 삽입,"XQuery, XPath 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이 실행가능한 보안약점","// 프로퍼티로부터 외부 입력값 name과 password를 읽어와 각각 nm, pw변수에 저장
+String nm = props.getProperty(""name"");
+String pw = props.getProperty(""password"");
+......
+XPathFactory factory = XPathFactory.newInstance();
+XPath xpath = factory.newXPath();
+......
+// 검증되지 않은 입력값 외부 입력값 nm, pw 를 사용하여 안전하지 않은 질의문이 작성되어 expr
+ 변수에 저장된다.
+XPathExpression expr = xpath.compile(""//users/user[login/text()='""+nm+""' and
+ password/text()='""+pw+""']/home_dir/text()"");
+// 안전하지 않은 질의문이 담긴 expr을 평가하여 결과를 result에 저장한다.
+Object result = expr.evaluate(doc, XPathConstants.NODESET);
+// result의 결과를 NodeList 타입으로 변환하여 nodes 저장한다.
+NodeList nodes = (NodeList) result;
+for (int i=0; i<nodes.getLength(); i++) {
+ String value = nodes.item(i).getNodeValue();
+ if (value.indexOf("">"") < 0) {
+ // 공격자가 이름과 패스워드를 확인할 수 있다. System.out.println(value);
+ }
+}","[ login.xq 파일 ]
+declare variable $loginID as xs:string external; declare variable $password as xs:string
+external;
+//users/user[@loginID=$loginID and @password=$password]
+// XQuery를 이용한 XPath Injection 방지
+String nm = props.getProperty(""name"");
+String pw = props.getProperty(""password"");
+Document doc = new Builder().build(""users.xml"");
+// 파라미터화된 쿼리가 담겨있는 login.xq를 읽어와서 파라미터화된 쿼리를 생성한다.
+XQuery xquery = new XQueryFactory().createXQuery(new File(""login.xq""));
+Map vars = new HashMap();
+// 검증되지 않은 외부값인 nm, pw를 파라미터화된 쿼리의 파라미터로 설정한다.
+vars.put(""loginID"", nm);
+vars.put(""password"", pw);
+// 파라미터화된 쿼리를 실행하므로 외부값을 검증없이 사용하여도 안전하다.
+Nodes results = xquery.execute(doc, null, vars).toNodes();
+for (int i=0; i<results.size(); i++) {
+ System.out.println(results.get(i).toXML());
+}"
+JAVA,입력데이터 검증 및 표현,XML 삽입,"XQuery, XPath 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이 실행가능한 보안약점","// 프로퍼티로부터 외부 입력값 name과 password를 읽어와 각각 nm, pw변수에 저장
+String nm = props.getProperty(""name"");
+String pw = props.getProperty(""password"");
+......
+XPathFactory factory = XPathFactory.newInstance();
+XPath xpath = factory.newXPath();
+......
+// 검증되지 않은 입력값 외부 입력값 nm, pw 를 사용하여 안전하지 않은 질의문이 작성되어 expr
+ 변수에 저장된다.
+XPathExpression expr = xpath.compile(""//users/user[login/text()='""+nm+""' and
+ password/text()='""+pw+""']/home_dir/text()"");
+// 안전하지 않은 질의문이 담긴 expr을 평가하여 결과를 result에 저장한다.
+Object result = expr.evaluate(doc, XPathConstants.NODESET);
+// result의 결과를 NodeList 타입으로 변환하여 nodes 저장한다.
+NodeList nodes = (NodeList) result;
+for (int i=0; i<nodes.getLength(); i++) {
+ String value = nodes.item(i).getNodeValue();
+ if (value.indexOf("">"") < 1) {
+ // 공격자가 이름과 패스워드를 확인할 수 있다. System.out.println(value);
+ }
+}","// XPath 삽입을 유발할 수 있는 문자들을 입력값에서 제거
+public String XPathFilter(String input) {
+    if (input != null) return input.replaceAll(""[',￦￦[]"", """");
+    else return """";
+   }
+   ......
+   // 외부 입력값에 사용
+   String nm = XPathFilter(props.getProperty(""name""));
+   String pw = XPathFilter(props.getProperty(""password""));
+   ......
+   XPathFactory factory = XPathFactory.newInstance();
+   XPath xpath = factory.newXPath();
+   ......
+   // 외부 입력값인 nm, pw를 검증하여 쿼리문을 생성하므로 안전하다.
+   XPathExpression expr = xpath.compile(""//users/user[login/text()='""+nm+""' and
+    password/text()='""+pw+""']/home_dir/text()"");
+   Object result = expr.evaluate(doc, XPathConstants.NODESET);
+   NodeList nodes = (NodeList) result;
+   for (int i=0; i<nodes.getLength(); i++) {
+    String value = nodes.item(i).getNodeValue();
+ if (value.indexOf("">"") < 0) {
+ System.out.println(value);
+ }
+}
+ ......"
+JAVA,입력데이터 검증 및 표현,XML 삽입,"XQuery, XPath 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이 실행가능한 보안약점","public static void main(String[] args) throws Exception {
+ if (args.length <= 0) {
+ System.err.println(""가격을 검색할 식품의 이름을 입력하세요.""); return;
+ }
+ String name = args[0];
+ DocumentBuilder docBuilder =
+ DocumentBuilderFactory.newInstance().newDocumentBuilder();
+Document doc = docBuilder.parse(""http://www.w3schools.com/xml/simple.xml"");
+ Xpath xpath = XPathFactory.newInstance().newXPath();
+// 프로그램의 커맨드 옵션으로 입력되는 외부값 name을 사용하여 쿼리문을 직접 작성하여 수행하므로 안전하지 않다.
+ NodeList nodes = (NodeList) xpath.evaluate(“//food[name=‘” + name +
+ “’]/price”, doc, XPathConstants.NODESET);
+ for (int i = 0; i < nodes.getLength(); i++) {
+ System.out.println(nodes.item(i).getTextContent());
+ }
+}","public static void main(String[] args) throws Exception {
+ if (args.length <= 0) {
+ System.err.println(""가격을 검색할 식품의 이름을 입력하세요."");
+ return;
+ }
+/*프로그램의 커맨드 옵션으로 입력되는 외부값 name에서 XPath 구문을 조작할 수 있는 문자를
+ 제거하는 검증을 수행하여 안전하다.*/
+ String name = args[0];
+ if (name != null) {
+ name = name.replaceAll(""[()￦￦-'￦￦[￦￦]:,*/]"", """");
+ }
+ DocumentBuilder docBuilder =
+ DocumentBuilderFactory.newInstance().newDocumentBuilder();
+ Document doc = docBuilder.parse(""http://www.w3schools.com/xml/simple.xml"");
+ XPath xpath = XPathFactory.newInstance().newXPath();
+ NodeList nodes = (NodeList) xpath.evaluate(“//food[name='"" + name + ""']/price"",
+doc, XPathConstants.NODESET);
+ for (int i = 0; i < nodes.getLength(); i++) {
+ System.out.println(nodes.item(i).getTextContent());
+ }
+}"
+C#,입력데이터 검증 및 표현,XML 삽입,"XQuery, XPath 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이 실행가능한 보안약점","string acctID = Request[""acctID""];
+string query = null; if(acctID != null)
+{
+StringBuffer sb = new StringBuffer(""/accounts/account[acctID='""); sb.Append(acctID);
+sb.Append(""']/email/text()""); query = sb.ToString();
+}
+XPathDocument docNav = new XPathDocument(myXml); XPathNavigator nav =
+docNav.CreateNavigator();
+//외부 입력값을 검증없이 사용하고 있습니다.
+nav.Evaluate(query);","string xpath = ""/accounts/account[@acctID=$acctID]/email/text()"";
+ XPathExpression expr = DynamicContext.Compile(xpath);
+ DynamicContext ctx = new DynamicContext();
+ctx.AddVariable(""acctID"", AccountIDTextBox.Text);
+ expr.SetContext(ctx);
+ XPathNodeIterator data = nav.Select(expr);"
+JAVA,입력데이터 검증 및 표현,LDAP 삽입,LDAP 명령문을 생성할 때 검증되지 않은 외부 입력 값을 허용하여 악의적인 명령어가 실행가능한 보안약점,"private void searchRecord(String userSN, String userPassword) throws
+ NamingException {
+ Hashtable<String, String> env = new Hashtable<String, String>();
+ env.put(Context.INITIAL_CONTEXT_FACTORY,
+""com.sun.jndi.ldap.LdapCtxFactory"");
+ try {
+ DirContext dctx = new InitialDirContext(env);
+ SearchControls sc = new SearchControls();
+ String[] attributeFilter = { ""cn"", ""mail"" };
+ sc.setReturningAttributes(attributeFilter);
+ sc.setSearchScope(SearchControls.SUBTREE_SCOPE);
+ String base = ""dc=example,dc=com"";
+/*userSN과 userPassword 값에 LDAP필터를 조작할 수 있는 공격 문자열에 대한 검증이 없어
+ 안전하지 않다.*/
+ String filter = ""(&(sn="" + userSN + "")(userPassword="" + userPassword + ""))"";
+ NamingEnumeration<?> results = dctx.search(base, filter, sc);
+ while (results.hasMore()) {
+ SearchResult sr = (SearchResult) results.next();
+ Attributes attrs = sr.getAttributes();
+ Attribute attr = attrs.get(""cn"");
+ .....
+ }
+ dctx.close();
+ } catch (NamingException e) { … }
+}","private void searchRecord(String userSN, String userPassword) throws
+ NamingException {
+ Hashtable<String, String> env = new Hashtable<String, String>();
+ env.put(Context.INITIAL_CONTEXT_FACTORY,
+""com.sun.jndi.ldap.LdapCtxFactory"");
+ try {
+ DirContext dctx = new InitialDirContext(env);
+ SearchControls sc = new SearchControls();
+ String[] attributeFilter = {""cn"", ""mail"" };
+ sc.setReturningAttributes(attributeFilter);
+sc.setSearchScope(SearchControls.SUBTREE_SCOPE);
+ String base = ""dc=example,dc=com"";
+// userSN과 userPassword 값에서 LDAP 필터를 조작할 수 있는 문자열을 제거하고 사용
+if (!userSN.matches(""[￦￦w￦￦s]*"") || !userPassword.matches(""[￦￦w]*"")) {
+    throw new IllegalArgumentException(""Invalid input"");
+    }
+    String filter = ""(&(sn="" + userSN + "")(userPassword="" + userPassword + ""))"";
+    NamingEnumeration<?> results = dctx.search(base, filter, sc);
+    while (results.hasMore()) {
+    SearchResult sr = (SearchResult) results.next();
+    Attributes attrs = sr.getAttributes();
+    Attribute attr = attrs.get(""cn"");
+    ......
+    }
+    dctx.close();
+    } catch (NamingException e) { … }
+   }"
+C#,입력데이터 검증 및 표현,LDAP 삽입,LDAP 명령문을 생성할 때 검증되지 않은 외부 입력 값을 허용하여 악의적인 명령어가 실행가능한 보안약점,"static void SearchRecord(string userSN, string userPW)
+{
+try {
+ DirectoryEntry oDE;
+ oDE = new DirectoryEntry(GetStrPath());
+ // 인증을 하지않은 익명 바인딩으로 LDAP 쿼리를 실행
+ foreach(DirectoryEntry objChildDE om oDE.Children) {
+...
+}
+ } catch (NamingException e) { ... }
+}","void LDAPInjection() {
+ char *filter = getenv(“Filter”);
+ int error_code;
+ LDAP *ld = NULL;
+ LDAPMessage *result;
+ // 외부에서 불러온 filter를 검증없이 사용
+ error_code = ldap_search_ext_s(ld, FIND_DN, LDAP_SCOPE_BASE, filter,
+ NULL, 0, NULL, NULL, LDAP_NO_LIMIT, LDAP_NO_LIMIT, &result);
+}"
+C,입력데이터 검증 및 표현,LDAP 삽입,LDAP 명령문을 생성할 때 검증되지 않은 외부 입력 값을 허용하여 악의적인 명령어가 실행가능한 보안약점,"void LDAPInjection() {
+ char *filter = getenv(“Filter”);
+ int error_code;
+ LDAP *ld = NULL;
+ LDAPMessage *result;
+ // 외부에서 불러온 filter를 검증없이 사용
+ error_code = ldap_search_ext_s(ld, FIND_DN, LDAP_SCOPE_BASE, filter,
+ NULL, 0, NULL, NULL, LDAP_NO_LIMIT, LDAP_NO_LIMIT, &result);
+}","void LDAPInjection() {
+char *filter = getenv(“Filter”);
+int error_code; int i;
+LDAP *ld = NULL;
+LDAPMessage *result;
+// 정보를 알고 싶은 사용자의 이름을 고정 ���으로 사용
+ for(i = 0; *(filter + i) != 0; i++) {
+// 공격 가능한 문자열 검사
+ switch(*(filter + i)) {
+ case ‘*’:
+ case ‘(’:
+ case ‘)’:
+ …
+ return;
+ }
+}
+error_code = ldap_search_ext_s(ld, FIND_DN, LDAP_SCOPE_BASE, filter,
+NULL, 0, NULL, NULL, LDAP_NO_LIMIT, LDAP_NO_LIMIT, &result);
+}"
+JAVA,입력데이터 검증 및 표현,크로스사이트 요청 위조,사용자 브라우저에 검증되지 않은 외부 입력 값을 허용하여 사용자 본인의 의지와는 무관하게 공격자가 의도한 행위가 실행 가능한 보안약점,// 어떤 형태의 요청이던지 기본적으로 CSRF 취약점을 가질 수 있다.,"// 입력화면이 요청되었을 때, 임의의 토큰을 생성한 후 세션에 저장한다.
+session.setAttribute(""SESSION_CSRF_TOKEN"", UUID.randomUUID().toString());
+// 입력화면에 임의의 토큰을 HIDDEN 필드항목의 값으로 설정해 서버로 전달되도록 한다.
+<input type=""hidden"" name=""param_csrf_token"" value=""$ {SESSION_CSRF_TOKEN }""/>
+// 요청 파라미터와 세션에 저장된 토큰을 비교해서 일치하는 경우에만 요청을 처리한다.
+String pToken = request.getParameter(""param_csrf_token"");
+String sToken = (String)session.getAttribute(""SESSION_CSRF_TOKEN"");
+if (pToken != null && pToken.equals(sToken) {
+ // 일치하는 토큰이 존재하는 경우 -> 정상 처리
+ ......
+} else {
+ // 토큰이 없거나 값이 일치하지 않는 경우 -> 오류 메시지 출력
+ ......
+}"
+C#,입력데이터 검증 및 표현,크로스사이트 요청 위조,사용자 브라우저에 검증되지 않은 외부 입력 값을 허용하여 사용자 본인의 의지와는 무관하게 공격자가 의도한 행위가 실행 가능한 보안약점,// 어떤 형태의 요청이던지 기본적으로 CSRF 취약점을 가질 수 있다.,"/*
+
+@using (Html.BeginForm(""PostTest"",""Home"",FormMethod.Post,null))
+{
+ // AntiForgeryToken() 을 이용해 크로스사이트 요청 위조를 방지
+ @Html.AntiForgeryToken()
+ <input type=""submit"" value=""Html PsBk Click"" />
+}
+
+*/"
+JAVA,입력데이터 검증 및 표현,서버사이드 요청 위조,서버 간 처리되는 요청에 검증되지 않은 외부 입력값을 허용하여 공격자가 의도한 서버로 전송하거나 변조하는 보안약점,"protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws
+IOException {
+// 사용자 입력값(url)을 검증없이 사용하여 안전하지 않다.
+URL url = new URL(req.getParameter(""url""));
+HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+ }"," public class Connect {
+// key, value 형식으로 URL의 리스트를 작성한다.
+ private Map<String, URL> urlMap;
+ protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws
+IOException {
+// 사용자에게 urlMap의 key를 입력받아 urlMap에서 URL값을 참조한다.
+URL url = urlMap.get(req.getParameter(""url""));
+// urlMap에서 참조한 값으로 Connection을 만들어 접속한다.
+ HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+ }
+}"
+JAVA,입력데이터 검증 및 표현,HTTP 응답분할,HTTP 응답헤더에 개행문자(CR이나 LF)가 포함된 검증되지 않은 외부 입력값을 허용하여 악의적인 코드가 실행 가능한 보안약점,"// 외부로부터 입력받은 값을 검증 없이 사용할 경우 안전하지 않다.
+String lastLogin = request.getParameter(""last_login"");
+if (lastLogin == null || """".equals(lastLogin)) {
+ return;
+}
+// 쿠키는 Set-Cookie 응답헤더로 전달되므로 개행문자열 포함 여부 검증이 필요
+Cookie c = new Cookie(""LASTLOGIN"", lastLogin);
+c.setMaxAge(1000);
+c.setSecure(true);
+response.addCookie(c);
+response.setContentType(""text/html"");","String lastLogin = request.getParameter(""last_login"");
+if (lastLogin == null || """".equals(lastLogin)) {
+ return;
+}
+// 외부 입력값에서 개행문자(￦r￦n)를 제거한 후 쿠키의 값으로 설정
+lastLogin = lastLogin.replaceAll(""[￦￦r￦￦n]"", """");
+Cookie c = new Cookie(""LASTLOGIN"", lastLogin);
+c.setMaxAge(1000);
+c.setSecure(true);
+response.addCookie(c);"
+C#,입력데이터 검증 및 표현,HTTP 응답분할,HTTP 응답헤더에 개행문자(CR이나 LF)가 포함된 검증되지 않은 외부 입력값을 허용하여 악의적인 코드가 실행 가능한 보안약점,"// 외부 입력값을 검증없이 사용하는 것은 안전하지 않다.
+string usrInput = Request.QueryString[""ID""];
+Response.AddHeader(""foo"", ""bar"" + usrInput);","ring usrInput = Request.QueryString[""ID""];
+// 개행문자를 제거 한 이후에 사용해야 한다.
+ring validatedInput = usrInput.Replace(""￦n"", """").Replace(""￦r"","""");
+sponse.AddHeader(""foo"", ""bar"" + validatedInput);"
+JAVA,입력데이터 검증 및 표현,정수형 오버플로우,정수형 변수에 저장된 값이 허용된 정수 값 범위를 ���어나 프로그램이 예기치 않게 동작 가능한 보안약점,"String msg_str = """";
+String tmp = request.getParameter(""slf_msg_param_num"");
+tmp = StringUtil.isNullTrim(tmp);
+if (tmp.equals(""0"")) {
+ msg_str = PropertyUtil.getValue(msg_id);
+} else {
+ // 외부 입력값을 정수형으로 사용할 때 입력값의 크기를 검증하지 않고 사용
+ int param_ct = Integer.parseInt(tmp);
+ String[] strArr = new String[param_ct];","String msg_str = """";
+String tmp = request.getParameter(""slf_msg_param_num"");
+tmp = StringUtil.isNullTrim(tmp);
+if (tmp.equals(""0"")) {
+ msg_str = PropertyUtil.getValue(msg_id);
+} else {
+// 외부 입력값을 정수형으로 사용할 때 입력값의 크기를 검증하고 사용
+try {
+ int param_ct = Integer.parseInt(tmp);
+ if (param_ct < 0) {
+ throw new Exception();
+ }
+ String[] strArr = new String[param_ct];
+} catch(Exception e) {
+ msg_str = ""잘못된 입력(접근) 입니다."";
+}"
+C#,입력데이터 검증 및 표현,정수형 오버플로우,정수형 변수에 저장된 값이 허용된 정수 값 범위를 벗어나 프로그램이 예기치 않게 동작 가능한 보안약점,"public static void Main(string[] args)
+{
+ // 외부 입력값을 사용할 때, 입력 값의 크기가 너무 클 경우 오버플로우 발생
+ int usrNum = Int32.Parse(args[0]);
+ string[] array = {""one"", ""two"", ""three"", ""four"" };
+ string num = array[usrNum];
+}","public static void Main(string[] args)
+{
+ // checked 구문을 사용하여 오버플로우의 발생 여부 및 크기 확인
+ try {
+ int usrNum = checked(Int32.Parse(args[0]));
+ string[] array = {""one"", ""two"", ""three"", ""four"" };
+ if(usrNum < 3)string num = array[usrNum];
+ }
+ catch (System.OverflowException e) { … }
+}"
+C,입력데이터 검증 및 표현,정수형 오버플로우,정수형 변수에 저장된 값이 허용된 정수 값 범위를 벗어나 프로그램이 예기치 않게 동작 가능한 보안약점,"id main(int argc, char* argv[])
+// 외부 입력값을 사용할 때, 입력 값의 크기가 너무 클 경우 오버플로우 발생
+int usr_num = 0;
+char* num_array[] = {“one”, “two”, “three”, “four” };
+char* num = NULL;
+usr_num = atoi(argv[1]);
+num = num_array[usr_num];
+}","id main(int argc, char* argv[])
+ // 외부 입력값을 사용할 때, 입력 값의 크기가 너무 클 경우 오버플로우 발생
+int usr_num = 0;
+ char* num_array[] = {“one”, “two”, “three”, “four” };
+ char* num = NULL;
+ usr_num = atoi(argv[1]);
+ if (usr_num >= 0 && usr_num < 4) {
+ num = num_array[usr_num];
+}
+ }"
+JAVA,입력데이터 검증 및 표현,보안기능 결정에 사용되는 부적절한 입력값,"보안기능(인증, 권한부여 등) 결정에 검증되지 않은 외부 입력값을 허용하여 보안기능을 우회하는 보안약점","<input type=""hidden"" name=""price"" value=""1000""/>
+<br/>품목 : HDTV
+<br/>수량 : <input type=""hidden"" name=""quantity"" />개
+<br/><input type=""submit"" value=""구입"" />
+......
+
+try {
+    // 서버가 보유하고 있는 가격(단가) 정보를 사용자 화면에서 받아서 처리
+    price = request.getParameter(""price"");
+    quantity = request.getParameter(""quantity"");
+    total = Integer.parseInt(quantity) * Float.parseFloat(price);
+   } catch (Exception e) {
+   ......","<input type=""hidden"" name=""price"" value=""1000""/>
+<br/>품목 : HDTV
+<br/>수량 : <input type=""hidden"" name=""quantity"" />개
+<br/><input type=""submit"" value=""구입"" />
+......
+try {
+ item = request.getParameter(“item”);
+ // 가격이 아니라 item 항목을 가져와서 서버가 보유하고 있는 가격정보를 이용하여 전체 가격을
+계산
+ price = productService.getPrice(item);
+ quantity = request.getParameter(""quantity"");
+ total = Integer.parseInt(quantity) * price;
+} catch (Exception e) {
+ ......
+}
+......"
+C#,입력데이터 검증 및 표현,보안기능 결정에 사용되는 부적절한 입력값,"보안기능(인증, 권한부여 등) 결정에 검증되지 않은 외부 입력값을 허용하여 보안기능을 우회하는 보안약점","HttpCookie cookie = new HttpCookie(“Authentificated”, “1”);
+//평문으로 사용자의 인증정보를 쿠키에 저장한다.
+Response.Cookies.Add(cookie);","// 사용자의 인증정보를 세션에 저장한다.
+Session[“Authentificated”] = “1”;"
+"C, C#",입력데이터 검증 및 표현,보안기능 결정에 사용되는 부적절한 입력값,"보안기능(인증, 권한부여 등) 결정에 검증되지 않은 외부 입력값을 허용하여 보안기능을 우회하는 보안약점","void SecurityDecision() {
+ int sockfd = socket(PF_INET, SOCK_STREAM, 0);
+ char* server_info = getenv(“server_addr”);
+ // 외부에서 가져온 서버 정보를 그대로 사용한다.
+ if( connect( sockfd, (struct sockaddr *)server_addr, sizeof(struct socketaddr) ) < 0 ) {
+ return;
+ }
+ /* 라이선스 검증 코드 */
+}","void SecurityDecision() {
+ int sockfd = socket(PF_INET, SOCK_STREAM, 0);
+ struct sockaddr_in server_addr;
+ memset( &server_ info, 0, sizeof(server_info));
+ server_info.sin_family = AF_INET;
+ server_info.sin_port = htons(5555);
+ server_info.sin_addr.s_addr = inet_addr(“127.0.0.1”);
+ // 고정된 서버 주소를 사용하여 연결을 진행한다.
+ if( connect( sockfd, (struct sockaddr *)server_addr, sizeof(struct socketaddr) ) < 0 ) {
+ return;
+ }
+ /* 라이선스 검증 코드 */
+}"
+C,입력데이터 검증 및 표현,메모리 버퍼 오버플로우,메모리 버퍼의 경계값을 넘어서 메모리값을 읽거나 저장하여 예기치 않은 결과가 발생하는 보안약점,"typedef struct _charvoid {
+ char x[16];
+ void * y;
+ void * z;
+} charvoid
+void badCode() {
+ charvoid cv_struct
+ cv_struct.y = (void *) SRC_STR;
+ printLine((char *) cv_struct.y);
+
+ /* sizeof(cv_struct)의 사용으로 포인터 y에 덮어쓰기 발생 */
+ memcpy(cv_struct.x, SRC_STR, sizeof(cv_struct));
+ printLine((char *) cv_struct.x);
+ printLine((char *) cv_struct.y);15:
+}","typedef struct _charvoid {
+ char x[16];
+ void * y;
+ void * z;
+} charvoid
+static void goodCode() {
+ charvoid cv_struct
+ cv_struct.y = (void *) SRC_STR;
+ printLine((char *) cv_struct.y);
+ /* sizeof(cv_struct.x)로 변경하여 포인터 y의 덮어쓰기를 방지함 */
+ memcpy(cv_struct.x, SRC_STR, sizeof(cv_struct.x));
+ /* 문자열 종료를 위해 널 문자를 삽입함 */
+ cv_struct.x[(sizeof(cv_struct.x)/sizeof(char))-1] = '￦0';
+ printLine((char *) cv_struct.x);
+ printLine((char *) cv_struct.y);
+}"
+JAVA,입력데이터 검증 및 표현,포맷 스트링 삽입,"printf 등 포맷 스트링 제어함수에 검증되지 않은 외부 입력값을 허용하여 발생하는 보안약점
+* 포맷 스트링: 입·출력에서 형식이나 형태를 지정해주는 문자열","// 외부 입력값에 포맷 문자열 포함 여부를 확인하지 않고 포맷 문자열 출력에 값으로 사용
+// args[0]의 값으로 “%1$tY-%1$tm-%1$te""를 전달하면 시스템에서 가지고 있는 날짜
+(2014-10-14) 정보가 노출
+import java.util.Calendar
+
+public static void main(String[] args) {
+    Calendar validDate = Calendar.getInstance();
+ validDate.set(2014, Calendar.OCTOBER, 14);
+ System.out.printf( args[0] + "" did not match! HINT: It was issued on %1$terd
+ of some month"", validate);
+}","// 외부 입력값이 포맷 문자열 출력에 사용되지 않도록 수정
+import java.util.Calendar
+ :
+public static void main(String[] args) {
+ Calendar validDate = Calendar.getInstance();
+ validDate.set(2014, Calendar.OCTOBER, 14);
+ System.out.printf(""%s did not match! HINT: It was issued on %2$terd of some
+ month"", args[0], validate);
+}"
+C,입력데이터 검증 및 표현,포맷 스트링 삽입,"printf 등 포맷 스트링 제어함수에 검증되지 않은 외부 입력값을 허용하여 발생하는 보안약점
+* 포맷 스트링: 입·출력에서 형식이나 형태를 지정해주는 문자열","void incorrect_password(const char *user)
+{
+    static const char msg_format[] = ""%s cannot be authenticated.￦n"";
+    size_t len = strlen(user) + sizeof(msg_format);
+    char *msg = (char *)malloc(len);
+    if (msg == NULL)
+    {
+        /* 오류 처리 */
+    }
+    int ret = snprintf(msg, len, msg_format, user);
+    if (ret < 0 || ret >= len)
+    {
+        /* 오류 처리 */
+    }
+    //
+    fprintf(stderr, msg);
+    free(msg);
+    msg = NULL;
+}","void incorrect_password(const char *user) {
+ static const char msg_format[] = ""%s cannot be authenticated.￦n"";
+ size_t len = strlen(user) + sizeof(msg_format);
+ char *msg = (char *)malloc(len);
+ if (msg == NULL) {
+ /* 오류 처리 */
+ }
+ int ret = snprintf(msg, len, msg_format, user);
+ if (ret < 0 || ret >= len) {
+ /* 오류 처리 */
+ }
+if (fputs(msg, stderr) == EOF) {
+ /* 오류 처리 */
+ }
+ free(msg);
+ msg = NULL;
+}"
+JAVA,보안기능,적절한 인증 없는 중요기능 허용,"중요정보(금융정보, 개인정보, 인증정보 등)를 적절한 인증없이 열람(또는 변경)가능한 보안약점","/* 
+@RequestMapping(value = ""/modify.do"", method = RequestMethod.POST)
+public ModelAndView memberModifyProcess(@ModelAttribute(""MemberModel"")
+MemberModel memberModel, BindingResult result, HttpServletRequest request,
+HttpSession session) {
+ModelAndView mav = new ModelAndView();
+//1. 로그인한 사용자를 불러온다.
+String userId = (String) session.getAttribute(""userId"");
+String passwd = request.getParameter(""oldUserPw"");
+...
+//2. 실제 수정하는 사용자와 일치 여부를 확인하지 않고, 회원정보를 수정하여 안전하지 않다.
+if (service.modifyMember(memberModel)) {
+mav.setViewName(""redirect:/board/list.do"");
+session.setAttribute(""userName"", memberModel.getUserName());
+return mav;
+} else {
+mav.addObject(""errCode"", 2);
+mav.setViewName(""/board/member_modify"");
+return mav;
+}
+}
+
+*/","/*
+@RequestMapping(value = ""/modify.do"", method = RequestMethod.POST)
+public ModelAndView memberModifyProcess(@ModelAttribute(""MemberModel"")
+MemberModel memberModel, BindingResult result, HttpServletRequest request,
+HttpSession session) {
+ModelAndView mav = new ModelAndView();
+//1. 로그인한 사용자를 불러온다.
+String userId = (String) session.getAttribute(""userId"");
+String passwd = request.getParameter(""oldUserPw"");
+//2. 회원정보를 실제 수정하는 사용자와 로그인 사용자와 동일한지 확인한다.
+String requestUser = memberModel.getUserId();
+if (userId != null && requestUser != null && !userId.equals(requestUser)) {
+mav.addObject(""errCode"", 1);
+mav.addObject(""member"", memberModel);
+mav.setViewName(""/board/member_modify"");
+return mav;
+}
+...
+
+//3. 동일한 경우에만 회원정보를 수정해야 안전하다.
+if (service.modifyMember(memberModel)) {
+ ...   
+}
+*/"
+C#,보안기능,적절한 인증 없는 중요기능 허용,"중요정보(금융정보, 개인정보, 인증정보 등)를 적절한 인증없이 열람(또는 변경)가능한 보안약점","protected void LoginButton_Click(object sender, EventArgs e) {
+// 사용자의 자격인증 과정이 없이 로그인 기능을 수행한다.
+FormsAuthentication.RedirectFromLoginPage(UserName.Text,
+RememberMe.Checked);
+}","protected void LoginButton_Click(object sender, EventArgs e) {
+// 사용자의 자격인증 과정을 수행한다.
+if(Membership.ValidateUser(UserName.Text, Password.Text)) {
+FormsAuthentication.RedirectFromLoginPage(UserName.Text,
+RememberMe.Checked);
+}
+}"
+JAVA,보안기능,부적절한 인가,중요자원에 접근할 때 적절한 제어가 없어 비인가자의 접근이 가능한 보안약점,"private BoardDao boardDao;
+String action = request.getParameter(""action"");
+String contentId = request.getParameter(""contentId"");
+// 요청을 하는 사용자의 delete 작원 권한 확인 없이 수행하고 있어 안전하지 않다.
+if (action != null && action.equals(""delete"")) {
+boardDao.delete(contentId);
+}","private BoardDao boardDao;
+String action = request.getParameter(""action"");
+String contentId = request.getParameter(""contentId"");
+// 세션에 저장된 사용자 정보를 얻어온다.
+User user= (User)session.getAttribute(""user"");
+// 사용자정보에서 해당 사용자가 delete작업의 권한이 있는지 확인한 뒤 삭제 작업을 수행한다.
+if (action != null && action.equals(""delete"") &&
+checkAccessControlList(user,action)) {
+boardDao.delete(contenId);
+}
+}"
+C#,보안기능,부적절한 인가,중요자원에 접근할 때 적절한 제어가 없어 비인가자의 접근이 가능한 보안약점,"// 운영자 권한 검사 없이 컨트롤러와 내부의 개별 액션에 접근 가능
+public class AdministrationController : Controller
+{
+...
+}","// 운영자 권한 검사 후 개별 액션에 접근
+[Authorize(Roles = ""Administrator"")]
+public class AdministrationController : Controller
+{
+...
+}"
+C,보안기능,부적절한 인가,중요자원에 접근할 때 적절한 제어가 없어 비인가자의 접근이 가능한 보안약점,"#define FIND_DN ""uid=han,ou=staff,dc=example,dc=com""
+int searchData2LDAP(LDAP *ld, char *username) {
+unsigned long rc;
+char filter[20];
+LDAPMessage *result;
+snprintf(filter, sizeof(filter),""(name=%s)"",username);
+// 사용자의 인증 없이 LDAP 검색을 시도한다.
+rc = ldap_search_ext_s(ld, FIND_DN, LDAP_SCOPE_BASE, filter, NULL, 0,
+NULL, NULL, LDAP_NO_LIMIT, LDAP_NO_LIMIT, &result);
+return rc;
+}","#define FIND_DN ""uid=han,ou=staff,dc=example,dc=com""
+int searchData2LDAP(LDAP *ld, char *username, char *password)
+{
+    unsigned long rc;
+    char filter[20];
+    LDAPMessage *result
+        // username 을 인증한다.
+        if (ldap_simple_bind_s(ld, username, password) != LDAP_SUCCESS)
+    {
+        printf(""authorization error"");
+        return (FAIL);
+    }
+    // username 이 로그인 정보와 일치하는지 검사한다.
+    if (strcmp(username, getLoginName()) != 0)
+    {
+        printf(""Login error"");
+        return (FAIL);
+    }
+    snprintf(filter, sizeof(filter), ""(name=%s)"", username);
+    rc = ldap_search_ext_s(ld, FIND_DN, LDAP_SCOPE_BASE, filter, NULL, 0,
+                           NULL, NULL, LDAP_NO_LIMIT, LDAP_NO_LIMIT, &result);
+    return rc;
+}"
+JAVA,보안기능,중요한 자원에 대한 잘못된 권한 설정,중요자원에 적절한 접근 권한을 부여하지 않아 중요정보가 노출·수정 가능한 보안약점,"File file = new File(""/home/setup/system.ini"");
+// 모든 사용자에게 실행 권한을 허용하여 안전하지 않다.
+file.setExecutable(true, false);
+// 모든 사용자에게 읽기 권한을 허용하여 안전하지 않다.
+file.setReadable(true, false);
+// 모든 사용자에게 쓰기 권한을 허용하여 안전하지 않다.
+file.setWritable(true, false);","File file = new File(""/home/setup/system.ini"");
+// 소유자에게 실행 권한을 금지하였다.
+file.setExecutable(false);
+// 소유자에게 읽기 권한을 허용하였다.
+file.setReadable(true);
+// 소유자에게 쓰기 권한을 금지하였다.
+file.setWritable(false);"
+C#,보안기능,중요한 자원에 대한 잘못된 권한 설정,중요자원에 적절한 접근 권한을 부여하지 않아 중요정보가 노출·수정 가능한 보안약점,"public static void AddDirectorySecurity(string FileName)
+{
+// 디렉토리 정보 객체 생성
+DirectoryInfo dInfo = new DirectoryInfo(FileName);
+DirectorySecurity dSecurity = dInfo.GetAccessControl();
+// 모든 사용자에게 권한 부여.
+dSecurity.AddAccessRule(new FileSystemAccessRule(""everyone"",
+FileSystemRights.FullControl,
+InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit,
+PropagationFlags.NoPropagateInherit, AccessControlType.Allow));
+dInfo.SetAccessControl(dSecurity);
+}","public static void AddDirectorySecurity(string FileName, string Account,
+FileSystemRights Rights, AccessControlType ControlType)
+{
+// 디렉토리 정보 객체 생성
+DirectoryInfo dInfo = new DirectoryInfo(FileName);
+DirectorySecurity dSecurity = dInfo.GetAccessControl();
+// FileSystemAccessRule 에 권한 설정
+dSecurity.AddAccessRule(new FileSystemAccessRule(Account,
+Rights,
+ControlType));
+dInfo.SetAccessControl(dSecurity);
+}"
+C,보안기능,중요한 자원에 대한 잘못된 권한 설정,중요자원에 적절한 접근 권한을 부여하지 않아 중요정보가 노출·수정 가능한 보안약점,"// 모든 사용자가 읽기/쓰기 권한을 갖게 된다.
+umask(0);
+FILE *out = fopen(""file_name"", ""w"");
+if(out) {
+fprintf(out, ""secure code￦n"");
+fclose(out);","// 유저 외에는 아무런 권한을 주지 않는다.
+umask(077);
+FILE *out = fopen(""file_name"", ""w"");
+if(out) {
+fprintf(out, ""secure code￦n"");
+fclose(out);"
+JAVA,보안기능,취약한 암호화 알고리즘 사용,"중요정보(금융정보, 개인정보, 인증정보 등)의 기밀성을 보장할 수 없는 취약한 암호화 알고리즘을 사용하여 정보가 노출 가능한 보안약점","import java.security.*;
+import javax.crypto.Cipher;
+import javax.crypto.NoSuchPaddingException;
+public class CryptoUtils {
+public byte[] encrypt(byte[] msg, Key k) {
+byte[] rslt = null;
+try {
+// 키 길이가 짧아 취약함 암호와 알고리즘인 DES를 사용하여 안전하지 않다.
+Cipher c = Cipher.getInstance(""DES"");
+c.init(Cipher.ENCRYPT_MODE, k);
+rslt = c.update(msg);
+}","import java.security.*;
+import javax.crypto.Cipher;
+import javax.crypto.NoSuchPaddingException;
+public class CryptoUtils {
+public byte[] encrypt(byte[] msg, Key k) {
+byte[] rslt = null;
+try {
+// 키 길이가 길어 강력한 알고리즘인 AES를 사용하여 안전하다.
+Cipher c = Cipher.getInstance(""AES/CBC/PKCS5Padding"");
+c.init(Cipher.ENCRYPT_MODE, k);
+rslt = c.update(msg);
+}"
+C#,보안기능,취약한 암호화 알고리즘 사용,"중요정보(금융정보, 개인정보, 인증정보 등)의 기밀성을 보장할 수 없는 취약한 암호화 알고리즘을 사용하여 정보가 노출 가능한 보안약점","static string Enc(string input) {
+// 키 길이가 짧아 취약함 암호와 알고리즘인 DES를 사용하여 안전하지 않다.
+var des = new DESCryptoServiceProvider();
+...
+}","static string Enc(string input) {
+// 키 길이가 길어 강력한 알고리즘인 AES를 사용하여 안전하다.
+var des = new AesCryptoServiceProvider();
+...
+}"
+C,보안기능,취약한 암호화 알고리즘 사용,"중요정보(금융정보, 개인정보, 인증정보 등)의 기밀성을 보장할 수 없는 취약한 암호화 알고리즘을 사용하여 정보가 노출 가능한 보안약점","EVP_CIPHER_CTX ctx;
+EVP_CIPHER_CTX_init(&ctx);
+// 취약한 DES 알고리즘을 사용한다.
+EVP_EncryptInit(&ctx, EVP_des_ecb(), NULL, NULL);","EVP_CIPHER_CTX ctx;
+EVP_CIPHER_CTX_init(&ctx);
+// 안전한 AES 알고리즘을 사용한다.
+EVP_EncryptInit(&ctx, EVP_aes_128_cbc(), key, iv);"
+JAVA,보안기능,암호화되지 않은 중요정보,"중요정보(비밀번호, 개인정보 등) 전송 시 암호화 또는 안전한 통신채널을 이용하지 않거나, 저장 시 암호화하지 않아 정보가 노출 가능한보안약점","String id = request.getParameter(""id"");
+// 외부값에 의해 패스워드 정보를 얻고 있다.
+String pwd = request.getParameter(""pwd"");
+......
+String sql = "" insert into customer(id, pwd, name, ssn, zipcode, addr)""
++ "" values (?, ?, ?, ?, ?, ?)"";
+PreparedStatement stmt = con.prepareStatement(sql);
+stmt.setString(1, id);
+stmt.setString(2, pwd);
+......
+// 입력받은 패스워드가 평문으로 DB에 저장되어 안전하지 않다.
+stmt.executeUpdate();","String id = request.getParameter(""id"");
+// 외부값에 의해 패스워드 정보를 얻고 있다.
+String pwd = request.getParameter(""pwd"");
+// 패스워드를 솔트값을 포함하여 SHA-256 해쉬로 변경하여 안전하게 저장한다.
+MessageDigest md = MessageDigest.getInstance(""SHA-256"");
+md.reset();
+md.update(salt);
+byte[] hashInBytes = md.digest(pwd.getBytes());
+StringBuilder sb = new StringBuilder();
+for (byte b : hashInBytes) {
+sb.append(String.format(""%02x"", b));
+}
+pwd = sb.toString();
+......
+String sql = "" insert into customer(id, pwd, name, ssn, zipcode, addr)""
++ "" values (?, ?, ?, ?, ?, ?)"";
+PreparedStatement stmt = con.prepareStatement(sql);
+stmt.setString(1, id);
+stmt.setString(2, pwd);
+......
+stmt.executeUpdate();"
+C#,보안기능,암호화되지 않은 중요정보,"중요정보(비밀번호, 개인정보 등) 전송 시 암호화 또는 안전한 통신채널을 이용하지 않거나, 저장 시 암호화하지 않아 정보가 노출 가능한보안약점","namespace Security
+{
+public class FindPassword : System.Web.UI.Page
+{
+protected void Page_Load(object sender, EventArgs e)
+{
+var userId = ""tmp"";
+MembershipUser user = Membership.GetUser(userId);
+if (user != null)
+{
+var password = user.GetPassword();
+Response.Write(password);
+}
+else
+{
+Response.Write(""the given userId is not valid"");
+}
+}
+}
+}","namespace Security
+{
+public class FindPassword : System.Web.UI.Page
+{
+protected void Page_Load(object sender, EventArgs e)
+{
+var userId = ""tmp"";
+MembershipUser user = Membership.GetUser(userId);
+if (user != null)
+{
+var encrypetedPassword = user.GetPassword();
+SecureFindPasswordFunction();
+}
+else
+{
+Response.Write(""the given userId is not valid"");
+}
+}
+}
+}"
+JAVA,보안기능,암호화되지 않은 중요정보,"중요정보(비밀번호, 개인정보 등) 전송 시 암호화 또는 안전한 통신채널을 이용하지 않거나, 저장 시 암호화하지 않아 정보가 노출 가능한보안약점","try {
+    Socket s = new Socket(""taranis"", 4444);
+    PrintWriter o = new PrintWriter(s.getOutputStream(), true);
+    // 패스워드를 평문으로 전송하여 안전하지 않다.
+    String password = getPassword();
+    o.write(password);
+    } catch (FileNotFoundException e) {
+    ......
+    }","// 패스워드를 암호화 하여 전송
+try {
+    Socket s = new Socket(""taranis"", 4444);
+    PrintStream o = new PrintStream(s.getOutputStream(), true);
+    // 패스워드를 강력한 AES암호화 알고리즘으로 전송하여 사용한다.
+    Cipher c = Cipher.getInstance(""AES/CBC/PKCS5Padding"");
+    String password = getPassword();
+    byte[] encPassword = c.update(password.getBytes());
+    o.write(encPassword, 0, encPassword.length);
+    } catch (FileNotFoundException e) {
+    ......
+    }"
+JAVA,보안기능,암호화되지 않은 중요정보,"중요정보(비밀번호, 개인정보 등) 전송 시 암호화 또는 안전한 통신채널을 이용하지 않거나, 저장 시 암호화하지 않아 정보가 노출 가능한보안약점","public void EmailPassword_OnClick(object sender, EventArgs args)
+{
+MembershipUser u = Membership.GetUser(UsernameTextBox.Text, false);
+String password;
+if (u != null)
+{
+try
+{
+password = u.GetPassword(); // sensitive data created
+}
+catch (Exception e)
+{
+Msg.Text = ""An exception occurred retrieving your password: "" +
+Server.HtmlEncode(e.Message);
+return;
+}
+MailMessage Message = new MailMessage();
+Message.Body = ""Your password is: "" + Server.HtmlEncode(password);
+//패스워드가 포함된 메시지를 네트워크로 전송하고 있다.
+SmtpMail.Send(Message);
+Msg.Text = ""Password sent via e-mail."";
+}
+else
+{
+Msg.Text = ""User name is not valid. Please check the value and try again."";
+}
+}","public void EmailPassword_OnClick(object sender, EventArgs args)
+{
+MembershipUser u = Membership.GetUser(UsernameTextBox.Text, false);
+String password;
+if (u != null)
+{
+try
+{
+password = u.GetPassword();
+byte[] data = System.Text.Encoding.ASCII.GetBytes(password);
+data = new
+System.Security.Cryptography.SHA256Managed().ComputeHash(data);
+String hashedPassword = System.Text.Encoding.ASCII.GetString(data);
+}
+catch (Exception e)
+{
+Msg.Text = ""An exception occurred retrieving your password: "" +
+Server.HtmlEncode(e.Message);
+return;
+}
+MailMessage Message = new MailMessage();
+Message.Body = ""Your password is: "" + Server.HtmlEncode(hasedPassword);
+SmtpMail.Send(Message);
+Msg.Text = ""Password sent via e-mail."";
+}
+else
+{
+Msg.Text = ""User name is not valid. Please check the value and try again."";
+}
+}"
+C,보안기능,암호화되지 않은 중요정보,"중요정보(비밀번호, 개인정보 등) 전송 시 암호화 또는 안전한 통신채널을 이용하지 않거나, 저장 시 암호화하지 않아 정보가 노출 가능한보안약점","int dbaccess()
+{
+    FILE *fp;
+    char *server = ""DBserver"";
+    char passwd[20];
+    char user[20];
+    SQLHENV henv;
+    SQLHDBC hdbc;
+    fp = fopen(""config"", ""r"");
+    fgets(user, sizeof(user), fp);
+    // 패스워드를 파일에서 읽어온다.
+    fgets(passwd, sizeof(passwd), fp);
+    fclose(fp);
+    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
+    SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc);
+    SQLConnect(hdbc,
+               (SQLCHAR *)server,
+               (SQLSMALLINT)strlen(server),
+               (SQLCHAR *)user,
+               (SQLSMALLINT)strlen(user),
+               // 패스워드 암호화 없이 직접 연결한다.
+               (SQLCHAR *)passwd,
+               (SQLSMALLINT)strlen(passwd));
+    return 0;
+}","int dbaccess()
+{
+    FILE *fp;
+    char *server = ""DBserver"";
+    char passwd[20];
+    char user[20];
+    char *encPasswd;
+    char *key;
+    SQLHENV henv;
+    SQLHDBC hdbc;
+    // AES-CBC로 암호화 모드를 설정한다.
+    HCkCrypt2 crypt = CkCrypt2_putCryptAlgorithm(crypt,”aes”);
+    CkCrypt2_putCipherMode(crypt,”cbc”);
+    // 외부에서 암호화 키를 불러와 설정한다.
+    key = getenv(“encrypt_key”);
+    CkCrypt2_SetEncodedKey(crypt, key,”hex”);
+    fp = fopen(""config"", ""r"");
+    fgets(user, sizeof(user), fp);
+    // 패스워드를 파일에서 읽어온다.
+    fgets(passwd, sizeof(passwd), fp);
+    fclose(fp);
+    // 패스워드 암호화를 진행한다.
+    encPasswd = CkCrypt2_encryptStringENC(crypt, passwd);
+    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
+    SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc);
+    SQLConnect(hdbc,
+               (SQLCHAR *)server,
+               (SQLSMALLINT)strlen(server),
+               (SQLCHAR *)user,
+               (SQLSMALLINT)strlen(user),
+               // 암호화된 패스워드를 사용한다.
+               (SQLCHAR *)encPasswd,
+               (SQLSMALLINT)strlen(verifiedPwd));
+    return 0;
+}"
+JAVA,보안기능,하드코드된 중요정보,"소스코드에 중요정보(비밀번호, 암호화키 등)를 직접 코딩하여 소스코드 유출 시 중요정보가 노출되고 주기적 변경이 어려운 보안약점","public class MemberDAO {
+private static final String DRIVER = ""oracle.jdbc.driver.OracleDriver"";
+private static final String URL = ""jdbc:oracle:thin:@192.168.0.3:1521:ORCL"";
+private static final String USER = ""SCOTT""; // DB ID;
+// DB 패스워드가 소스코드에 평문으로 저장되어 있다.
+private static final String PASS = ""SCOTT""; // DB PW;
+......
+public Connection getConn() {
+Connection con = null;
+try {
+Class.forName(DRIVER);
+con = DriverManager.getConnection(URL, USER, PASS);
+......","public class MemberDAO {
+private static final String DRIVER = ""oracle.jdbc.driver.OracleDriver"";
+private static final String URL = ""jdbc:oracle:thin:@192.168.0.3:1521:ORCL"";
+private static final String USER = ""SCOTT""; // DB ID
+......
+public Connection getConn() {
+Connection con = null;
+try {
+Class.forName(DRIVER);
+// 암호화된 패스워드를 프로퍼티에서 읽어들여 복호화해서 사용해야한다.
+String PASS = props.getProperty(""EncryptedPswd"");
+byte[] decryptedPswd = cipher.doFinal(PASS.getBytes());
+PASS = new String(decryptedPswd);
+con = DriverManager.getConnection(URL, USER, PASS);
+......"
+C#,보안기능,하드코드된 중요정보,"소스코드에 중요정보(비밀번호, 암호화키 등)를 직접 코딩하여 소스코드 유출 시 중요정보가 노출되고 주기적 변경이 어려운 보안약점","string UserName = ""username"";
+string Password = ""password"";
+// 평문으로 저장된 패스워드를 이용하여 NetworkCredential 생성
+NetworkCredential myCred = new NetworkCredential(UserName, Password);","string UserName = ""username"";
+string Password = ""password"";
+SecureString SecurelyStoredPassword = new SecureString();
+foreach (char c in Password)
+{
+SecurelyStoredPassword.AppendChar(c);
+}
+// 암호화된 패스워드를 사용하여 NetworkCredential 생성
+NetworkCredential secure_myCred = new NetworkCredential(UserName,
+SecurelyStoredPassword);"
+C,보안기능,하드코드된 중요정보,"소스코드에 중요정보(비밀번호, 암호화키 등)를 직접 코딩하여 소스코드 유출 시 중요정보가 노출되고 주기적 변경이 어려운 보안약점","int dbaccess(char *server, char *user) {
+SQLHENV henv;
+SQLHDBC hdbc;
+char *password = “password”;
+SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
+SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc);
+// 하드코드된 패스워드를 사용
+SQLConnect(hdbc,(SQLCHAR*)server,strlen(server),user,strlen(user),
+password, strlen(password));
+return 0;","int dbaccess(char *server, char *user, char *passwd) {
+SQLHENV henv;
+SQLHDBC hdbc;
+// 패스워드를 외부에서 불러와서 사용
+char *password = getenv(“password”);
+SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
+SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc);
+SQLConnect(hdbc, (SQLCHAR*) server, strlen(server), user, strlen(user),
+password, strlen(password));
+SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
+SQLFreeHandle(SQL_HANDLE_ENV, henv);
+return 0;
+}"
+JAVA,보안기능,하드코드된 중요정보,"소스코드에 중요정보(비밀번호, 암호화키 등)를 직접 코딩하여 소스코드 유출 시 중요정보가 노출되고 주기적 변경이 어려운 보안약점","import javax.crypto.KeyGenerator;
+import javax.crypto.spec.SecretKeySpec;
+import javax.crypto.Cipher;
+......
+public String encriptString(String usr) {
+// 암호화 키를 소스코드 내부에 사용하는 것은 안전하지 않다.
+String key = ""22df3023sf~2;asn!@#/>as"";
+if (key != null) {
+byte[] bToEncrypt = usr.getBytes(""UTF-8"");
+SecretKeySpec sKeySpec = new SecretKeySpec(key.getBytes(), ""AES"");","import javax.crypto.KeyGenerator;
+import javax.crypto.spec.SecretKeySpec;
+import javax.crypto.Cipher;
+......
+public String encriptString(String usr) {
+// 암호화 키는 외부 파일에서 암호화 된 형태로 저장하고, 사용시 복호화 한다.
+String key = getPassword(""./password.ini"");
+key = decrypt(key);
+if (key != null) {
+byte[] bToEncrypt = usr.getBytes(""UTF-8"");
+SecretKeySpec sKeySpec = new SecretKeySpec(key.getBytes(), ""AES"");"
+C#,보안기능,하드코드된 중요정보,"소스코드에 중요정보(비밀번호, 암호화키 등)를 직접 코딩하여 소스코드 유출 시 중요정보가 노출되고 주기적 변경이 어려운 보안약점","// 암호화 키를 소스코드 내부에 사용하는 것은 안전하지 않다.
+byte[] key = new byte[] { 0x43, 0x87, 0x23, 0x72 };
+byte[] iv = new byte[] { 0x43, 0x87, 0x23, 0x72 };
+FileStream fStream = File.Open(fileName, FileMode.OpenOrCreate);
+CryptoStream cStream = new CryptoStream(fStream,
+new TripleDESCryptoServiceProvider().CreateEncryptor(key, iv),
+CryptoStreamMode.Write);","// 암호화 키는 외부 파일에서 암호화 된 형태로 저장하고, 사용시 복호화 한다.
+byte[] key = GetKey(./password.ini);
+byte[] iv = GetIV(./password.ini);
+FileStream fStream = File.Open(fileName, FileMode.OpenOrCreate);
+CryptoStream cStream = new CryptoStream(fStream,
+new TripleDESCryptoServiceProvider().CreateEncryptor(Decrypt(key),
+Decrypt(iv)),
+CryptoStreamMode.Write);"
+C,보안기능,하드코드된 중요정보,"소스코드에 중요정보(비밀번호, 암호화키 등)를 직접 코딩하여 소스코드 유출 시 중요정보가 노출되고 주기적 변경이 어려운 보안약점","typedef int SQLSMALLINT;
+int dbaccess(char *user, char *passwd) {
+char *server = ""DBserver"";
+char *cpasswd;
+SQLHENV henv;
+SQLHDBC hdbc;
+SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
+SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc);
+// 암호화된 비밀번호와 솔트를 사용한다. 코드에 접근 권한이 있는 사용자는 해당 비밀번호와
+솔트를 획득할 수 있다.
+cpasswd = crypt(passwd, “salt”);
+if (strcmp(cpasswd, ""68af404b513073582b6c63e6b"") != 0) {
+// USE_OF_HARDCODED_CRYPTOGRAPHIC_KEY
+printf(""Incorrect password \n"");
+return -1;
+}","extern char *salt;
+typedef int SQLSMALLINT;
+int dbaccess(char *user, char *passwd) {
+char *server = ""DBserver"";
+char *cpasswd;
+// 외부에 있는 암호화된 비밀번호와 솔트를 불러온다.
+char* storedpasswd = getenv(“password”);
+char* salt = getenv(“salt”);
+SQLHENV henv;
+SQLHDBC hdbc;
+SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
+SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc);
+// 외부에서 불러온 솔트 값을 사용해 비빌번호를 암호화한다.
+cpasswd = crypt(passwd, salt);
+// 암호화된 비밀번호와 외부에서 불러온 값을 비교한다.
+if (strcmp(cpasswd, storedpasswd) != 0) {
+printf(""Incorrect password \n"");
+SQLFreeHandle(SQL_HANDLE_DBC, &hdbc);
+SQLFreeHandle(SQL_HANDLE_ENV, &henv);
+return -1;
+}
+}"
+JAVA,보안기능,충분하지 않은 키 길이 사용,암호화 등에 사용되는 키의 길이가 충분하지 않아 데이터의 기밀성·무결성을 보장할 수 없는 보안약점,"public static final String ALGORITHM = ""RSA"";
+public static final String PRIVATE_KEY_FILE = ""C:/keys/private.key"";
+public static final String PUBLIC_KEY_FILE = ""C:/keys/public.key"";
+public static void generateKey() {
+try {
+final KeyPairGenerator keyGen = KeyPairGenerator.getInstance(ALGORITHM);
+// RSA 키 길이를 1024 비트로 짧게 설정하는 경우 안전하지 않다.
+keyGen.initialize(1024);
+final KeyPair key = keyGen.generateKeyPair();
+File privateKeyFile = new File(PRIVATE_KEY_FILE);
+File publicKeyFile = new File(PUBLIC_KEY_FILE);","public static final String ALGORITHM = ""RSA"";
+public static final String PRIVATE_KEY_FILE = ""C:/keys/private.key"";
+public static final String PUBLIC_KEY_FILE = ""C:/keys/public.key"";
+public static void generateKey() {
+try {
+final KeyPairGenerator keyGen = KeyPairGenerator.getInstance(ALGORITHM);
+keyGen.initialize(2048);
+final KeyPair key = keyGen.generateKeyPair();
+File privateKeyFile = new File(PRIVATE_KEY_FILE);
+File publicKeyFile = new File(PUBLIC_KEY_FILE);"
+C#,보안기능,충분하지 않은 키 길이 사용,암호화 등에 사용되는 키의 길이가 충분하지 않아 데이터의 기밀성·무결성을 보장할 수 없는 보안약점,"static string UseRSA(string input) {
+// RSA 키 길이를 1024 비트로 짧게 설정하는 경우 안전하지 않다.
+var rsa = new RSACryptoServiceProvider(1024);
+...
+}","static string UseRSA(string input) {
+// RSA 키 길이를 2048 비트 이상으로 길게 설정한다.
+var rsa = new RSACryptoServiceProvider(2048);
+...
+}"
+C,보안기능,충분하지 않은 키 길이 사용,암호화 등에 사용되는 키의 길이가 충분하지 않아 데이터의 기밀성·무결성을 보장할 수 없는 보안약점,"EVP_PKEY *RSAKey() {
+EVP_PKEY *pkey;
+RSA *rsa;
+// RSA 키 길이를 512 비트로 짧게 설정하는 경우 안전하지 않다.
+rsa = RSA_generate_key(512, 35, NULL, NULL);
+if(rsa == NULL) {
+printf(""Error \n"");
+return NULL;
+}
+pkey = EVP_PKEY_new();
+EVP_PKEY_assign_RSA(pkey, rsa);
+return pkey;","EVP_PKEY *RSAKey() {
+EVP_PKEY *pkey;
+RSA *rsa;
+// 2048비트 이상으로 설정한 후에 사용해야 한다.
+rsa = RSA_generate_key(2048, 35, NULL, NULL);
+if(rsa == NULL) {
+printf(""Error \n"");
+return NULL;
+}
+pkey = EVP_PKEY_new();
+EVP_PKEY_assign_RSA(pkey, rsa);
+return pkey;
+}"
+JAVA,보안기능,적절하지 않은 난수값 사용,"사용한 난수가 예측 가능하여, 공격자가 다음 난수를 예상해서 시스템을 공격 가능한 보안약점","import java.util.Random;
+...
+public Static int getRandomValue(int maxValue) {
+// 고정된 시드값을 사용하여 동일한 난수값이 생성되어 안전하지 않다.
+Random random = new Random(100);
+return random.nextInt(maxValue);
+}
+public Static String getAuthKey() {
+// 매번 변경되는 시드값을 사용하여 다른 난수값이 생성되나 보안결정을 위한 난수로는 안전하지 않다.
+Random random = new Random();
+String authKey = Integer.toString(random.nextInt());","import java.util.Random;
+import java.security.SecureRandom;
+...
+public Static int getRandomValue(int maxValue) {
+// setSeed로 매번 변경되는 시드값을 설정 하거나, 기본값인 현재 시간 기반으로 매번 변경되는
+시드값을 사용하도록 한다.
+Random random = new Random();
+return random.nextInt(maxValue);
+}
+public Static String getAuthKey() {
+// 보안결정을 위한 난수로는 예측이 거의 불가능하게 암호학적으로 보호된 SecureRandom을
+사용한다.
+try {
+SecureRandom secureRandom = SecureRandom.getInstance(""SHA1PRNG"");
+MessageDigest digest = MessageDigest.getInstance(""SHA-256"");
+secureRandom.setSeed(secureRandom.generateSeed(128));
+String authKey = new String(digest.digest((secureRandom.nextLong() +
+"""").getBytes()));
+...
+} catch (NoSuchAlgorithmException e) {
+}"
+C#,보안기능,적절하지 않은 난수값 사용,"사용한 난수가 예측 가능하여, 공격자가 다음 난수를 예상해서 시스템을 공격 가능한 보안약점","static int GenerateDigit()
+{
+// 매번 변경되는 시드값을 사용하여 다른 난수값이 생성되나 보안결정을 위한 난수로는 안전하지 않다.
+Random rng = new Random();
+return rng.Next(10);
+}","static int GenerateDigitGood()
+{
+// 보안결정을 위한 난수로는 예측이 거의 불가능하게 암호학적으로 보호된
+SecureRandom을 사용한다.
+byte[] b = new byte[4];
+new System.Security.Cryptography.RNGCryptoServiceProvider().GetBytes(b);
+return (b[0] & 0x7f) << 24 | b[1] << 16 | b[2] << 8 | b[3];
+}"
+C,보안기능,적절하지 않은 난수값 사용,"사용한 난수가 예측 가능하여, 공격자가 다음 난수를 예상해서 시스템을 공격 가능한 보안약점","void foo() {
+int i;
+for(i=0; i<20; i++)
+// 프로그램을 여러 번 실행 했을 때 얻는 결과 값이 같다. 범위가 작기 때문에 암호화에 사용되기
+힘들다.
+printf(""%d"", rand());","void foo() {
+srandom(time(NULL));
+int i;
+for(i=0; i<20; i++)
+printf(""%ld"", random());
+}"
+JAVA,보안기능,취약한 비밀번호 허용,"비밀번호 조합규칙(영문, 숫자, 특수문자 등) 미흡 및 길이가 충분하지 않아 비밀번호가 노출 가능한 보안약점","String id = request.getParameter(""id"");
+String pass = request.getParameter(""pass"");
+UserVo userVO = new UserVo(id, pass);
+......
+// 비밀번호의 자릿수, 특수문자 포함 여부 등 복잡도를 체크하지 않고 등록
+String result = registerDAO.register(userVO);","String id = request.getParameter(""id"");
+String pass = request.getParameter(""pass"");
+// 비밀번호에 자릿수, 특수문자 포함 여부 등의 복잡도를 체크��고 등록하게 한다.
+Pattern pattern = Pattern.compile(""((?=.*[a-zA-Z])(?=.*[0-9@#$%]). {9, })"");
+Matcher matcher = pattern.matcher(pass);
+if (!matcher.matches()) {
+    return ""비밀번호 조합규칙 오류"";
+    }
+    UserVo userVO = new UserVo(id, pass);
+    ......
+    String result = registerDAO.register(userVO);"
+C#,보안기능,취약한 비밀번호 허용,"비밀번호 조합규칙(영문, 숫자, 특수문자 등) 미흡 및 길이가 충분하지 않아 비밀번호가 노출 가능한 보안약점","// 빈 비밀번호를 허용
+NetworkCredential myCred = new NetworkCredential(UserName, """");","// 빈 비밀번호를 사용하지 않음
+NetworkCredential secure_myCred = new NetworkCredential(UserName, Password);"
+C,보안기능,취약한 비밀번호 허용,"비밀번호 조합규칙(영문, 숫자, 특수문자 등) 미흡 및 길이가 충분하지 않아 비밀번호가 노출 가능한 보안약점","bool authentication(char *id, char *pwd)
+{
+    MYSQL *connectInstance;
+    connectInstance = mysql_init(NULL);
+    // 패스워드 값에 대한 검증없이 사용한다.
+    mysql_real_connect(connectInstance, ""192.168.100.211"", id, pwd,
+                       ""database"", 0, NULL, 0);
+    …
+}","bool authentication(char* id, char* pwd)
+{
+MYSQL *connectInstance;
+connectInstance = mysql_init(NULL);
+// 패스워드에 대한 적절한 검증을 수행해야 한다.
+if( checkValidationId( id ) == true && checkValidationPwd( pwd ) == true )
+{
+mysql_real_connect(connectInstance, ""192.168.100.211"", id, pwd,
+""database"", 0, NULL, 0);
+}
+...
+}"
+JAVA,보안기능,부적절한 전자서명 확인,"프로그램, 라이브러리, 코드의 전자서명에 대한 유효성 검증이 적절하지 않아 공격자의 악의적인 코드가 실행 가능한 보안약점","File f = new File(downloadedFilePath);
+JarFile jf = new JarFile(f);","File f = new File(downloadedFilePath);
+JarFile jf = new JarFile(f, true);
+Enumeration<JarEntry> ens = jf.entries();
+while (ens.hasMoreElements()) {
+JarEntry en = ens.nextElement();
+if (!en.isDirectory()) {
+if (en.toString().equals(path)) {
+byte[] data = readAll(jar.getInputStream(en), en.getSize());
+CodeSigner[] signers = en.getCodeSigners();
+...
+}
+}
+}
+jf.close();"
+C,보안기능,부적절한 인증서 유효성 검증,인증서에 대한 유효성 검증이 적절하지 않아 발생하는 보안약점,"if ((cert = SSL_get_peer_certificate(ssl)) && host)
+foo=SSL_get_verify_result(ssl);
+if ((X509_V_OK==foo) || X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN==foo))
+// 자체 서명된 인증서일 수 있다.","private boolean verifySignature(X509Certificate toVerify, X509Certificate signingCert) {
+/* 검증하려는 호스트 인증서(toVerify)와 CA인증서(signing Cert)의 DN(Distinguished
+Name)이 일치하는지 여부를 확인한다.*/
+if (!toVerify.getIssuerDN().equals(signingCert.getSubjectDN())) return false;
+try {
+// 호스트 인증서가 CA인증서로 서명 되었는지 확인한다.
+toVerify.verify(signingCert.getPublicKey());
+// 호스트 인증서가 유효기간이 만료되었는지 확인한다.
+toVerify.checkValidity();
+return true;
+} catch (GeneralSecurityException verifyFailed) {
+return false;
+}
+}"
+"C, JAVA",보안기능,부적절한 인증서 유효성 검증,인증서에 대한 유효성 검증이 적절하지 않아 발생하는 보안약점,"cert = SSL_get_peer_certificate(ssl);
+if (cert && (SSL_get_verify_result(ssl)==X509_V_OK)) {
+/* CN 을 확인하지 않았지만 신뢰하고 진행한다. 이럴 경우, 공격자가 Common Name을
+www.attack.com으로 설정하여 중간자 공격에 사용할 경우 데이터가 중간에서 복호화 되고 있음을
+탐지하지 못한다. */
+}","private boolean verifySignature(X509Certificate toVerify, X510Certificate signingCert) {
+/* 검증하려는 호스트 인증서(toVerify)와 CA인증서(signing Cert)의 DN(Distinguished
+Name)이 일치하는지 여부를 확인한다.*/
+if (!toVerify.getIssuerDN().equals(signingCert.getSubjectDN())) return false;
+try {
+// 호스트 인증서가 CA인증서로 서명 되었는지 확인한다.
+toVerify.verify(signingCert.getPublicKey());
+// 호스트 인증서가 유효기간이 만료되었는지 확인한다.
+toVerify.checkValidity();
+return true;
+} catch (GeneralSecurityException verifyFailed) {
+return false;
+}
+}"
+JAVA,보안기능,사용자 하드디스크에 저장되는 쿠키를 통한 정보노출,"쿠키(세션 ID, 사용자 권한정보 등 중요정보)를 사용자 하드디스크에 저장되어 중요정보가 노출 가능한 보안약점","Cookie loginCookie = new Cookie(""rememberme"", ""YES"");
+// 쿠키의 만료시간을 1년으로 과도하게 길게 설정하고 있어 안전하지 않다.
+loginCookie.setMaxAge(60*60*24*365);
+response.addCookie(loginCookie);","Cookie loginCookie = new Cookie(""rememberme"", ""YES"");
+// 쿠키의 만료시간은 해당 기능에 맞춰 최소로 사용한다.
+loginCookie.setMaxAge(60*60*24);
+response.addCookie(loginCookie);"
+C#,보안기능,사용자 하드디스크에 저장되는 쿠키를 통한 정보노출,"쿠키(세션 ID, 사용자 권한정보 등 중요정보)를 사용자 하드디스크에 저장되어 중요정보가 노출 가능한 보안약점","HttpCookie cookie = Request.Cookies.Get(“ExampleCookie”);
+// 쿠키의 만료시간을 1년으로 과도하게 길게 설정하고 있어 안전하지 않다.
+cookie.Expires = DateTime.Now.AddMinutes(60.0*24.0*365.0);
+Response.Cookies.Add(cookie);","HttpCookie cookie = Request.Cookies.Get(“ExampleCookie”);
+// 쿠키의 만료시간은 해당 기능에 맞춰 최소로 사용한다.
+cookie.Expires = DateTime.Now.AddMinutes(10d);
+Response.Cookies.Add(cookie);"
+JAVA,보안기능,주석문 안에 포함된 시스템 주요정보,소스코드 주석문에 인증정보 등 시스템 주요정보가 포함되어 소스코드 노출 시주요정보도 노출 가능한 보안약점,"// 주석문으로 DB연결 ID, 패스워드의 중요한 정보를 노출시켜 안전하지 않다.
+// DB연결 root / a1q2w3r3f2!@
+con = DriverManager.getConnection(URL, USER, PASS);","// ID, 패스워드등의 중요 정보는 주석에 포함해서는 안된다.
+con = DriverManager.getConnection(URL, USER, PASS);"
+C#,보안기능,주석문 안에 포함된 시스템 주요정보,소스코드 주석문에 인증정보 등 시스템 주요정보가 포함되어 소스코드 노출 시주요정보도 노출 가능한 보안약점,"// 주석문으로 DB연결 ID, 패스워드의 중요한 정보를 노출시켜 안전하지 않다.
+// DB연결 root / a1q2w3r3f2!@
+conn = customGetConnection(USER, PASS);","// ID, 패스워드등의 중요 정보는 주석에 포함해서는 안된다.
+conn = customGetConnection(USER, PASS);"
+C,보안기능,주석문 안에 포함된 시스템 주요정보,소스코드 주석문에 인증정보 등 시스템 주요정보가 포함되어 소스코드 노출 시주요정보도 노출 가능한 보안약점,"/* password is ""admin"" */
+/* passwd is ""admin"" */
+int verfiyAuth(char *ipasswd, char *orgpasswd) {
+char *admin = ""admin"";
+if(strncmp(ipasswd, oprgpasswd, sizeof(ipasswd)) != 0) {
+printf(""Authentication Fail! \n"");
+}
+return admin;","int verfiyAuth(char *ipasswd, char *orgpasswd) {
+char *admin = ""admin"";
+if(strncmp(ipasswd, oprgpasswd, sizeof(ipasswd)) != 0) {
+printf(""Authentication Fail! \n"");
+}
+return admin;
+}"
+JAVA,보안기능,솔트 없이 일방향 해쉬함수 사용,"솔트를 사용하지 않고 생성된 해쉬 값으로부터 공격자가 미리 계산된 레인보우 테이블을 이용하여 해쉬 적용 이전 원본 정보를 복원가능한 보안약점
+* 솔트: 해쉬 적용하기 전 평문인 전송정보에 덧붙인 무의미한 데이터","public String getPasswordHash(String password) throws Exception {
+ MessageDigest md = MessageDigest.getInstance(""SHA-256"");
+// 해쉬에 솔트를 적용하지 않아 안전하지 않다.
+ md.update(password.getBytes());
+ byte byteData[] = md.digest();
+ StringBuffer hexString = new StringBuffer();
+ for (int i=0; i<byteData.length i++) {
+ String hex=Integer.toHexString(0xff & byteData[i]);
+ if (hex.length() == 1) {
+ hexString.append('0');
+ }
+ hexString.append(hex);
+ }
+ return hexString.toString();
+}","public String getPasswordHash(String password, byte[] salt) throws Exception {
+ MessageDigest md = MessageDigest.getInstance(""SHA-256"");
+ md.update(password.getBytes());
+// 해쉬 사용 시에는 원문을 찾을 수 없도록 솔트를 사용하여야 한다.
+ md.update(salt);
+ byte byteData[] = md.digest();
+ StringBuffer hexString = new StringBuffer();
+ for (int i=0; i<byteData.length i++) {
+ String hex=Integer.toHexString(0xff & byteData[i]);
+ if (hex.length() == 1) {
+ hexString.append('0');
+ }
+ hexString.append(hex);
+ }
+ return hexString.toString()
+}"
+C#,보안기능,솔트 없이 일방향 해쉬함수 사용,"솔트를 사용하지 않고 생성된 해쉬 값으로부터 공격자가 미리 계산된 레인보우 테이블을 이용하여 해쉬 적용 이전 원본 정보를 복원가능한 보안약점
+* 솔트: 해쉬 적용하기 전 평문인 전송정보에 덧붙인 무의미한 데이터","static void HashWithoutSalt()
+{
+ // 해쉬에 솔트를 적용하지 않아 안전하지 않다.
+ var bytes = new byte[100];
+ (new Random()).NextBytes(bytes);
+ var source = bytes;
+ var sha256 = new SHA256CryptoServiceProvider();
+ sha256.ComputeHash(source);
+}","static void HashWithSalt(int saltLength)
+{
+ // 해쉬에 솔트를 적용하여 원문을 찾을 수 없게 한다.
+ var bytes = new byte[100];
+ (new Random()).NextBytes(bytes);
+ var source = bytes;
+ var sha256 = new SHA256CryptoServiceProvider();
+ byte[] saltBytes = GenerateRandomCryptographicBytes(saltLength);
+ List<byte> sourceWithSaltBytes = new List<byte>();
+ sourceWithSaltBytes.AddRange(source);
+ sourceWithSaltBytes.AddRange(sourceWithSaltBytes);
+ sha256.ComputeHash(sourceWithSaltBytes.ToArray());
+}"
+C,보안기능,솔트 없이 일방향 해쉬함수 사용,"솔트를 사용하지 않고 생성된 해쉬 값으로부터 공격자가 미리 계산된 레인보우 테이블을 이용하여 해쉬 적용 이전 원본 정보를 복원가능한 보안약점
+* 솔트: 해쉬 적용하기 전 평문인 전송정보에 덧붙인 무의미한 데이터","void GenerateHash(char* data)
+{
+ char[512] hashedData = {0 };
+//솔트 값 부분이 NULL 로 되어있어 들어가지 않는다.
+ MD5HashAlgorithm( data, hashedData, NULL );
+...
+}","void GenerateHash(char* data, char* salt)
+{
+ char hashedData[512] = {0 };
+ MD5HashAlgorithm( data, hashedData, salt );
+ ...
+}"
+JAVA,보안기능,무결성 검사 없는 코드 다운로드,"소스코드 또는 실행파일을 무결성 검사 없이 다운로드 받아 실행하는 경우, 공격자의 악의적인 코드가 실행 가능한 보안약점","URL[] classURLs = new URL[] { new URL(""file:subdir/"") };
+URLClassLoader loader = new URLClassLoader(classURLs);
+Class loadedClass = Class.forName(""LoadMe"", true, loader);","// 공개키 방식의 암호화 알고리즘과 메커니즘을 이용하여 전송파일에 대한 시그니처를 생성하고
+파일의 변조유무를 판단한다. 서버에서는 Private Key를 가지고 MyClass를 암호화한다.
+String jarFile = ""./download/util.jar"";
+byte[] loadFile = FileManager.getBytes(jarFile);
+loadFile = encrypt(loadFile, privateKey);
+// jarFileName으로 암호화된 파일을 생성한다.
+FileManager.createFile(loadFile, jarFileName);
+// 클라이언트에서는 파일을 다운로드 받을 경우 Public Key로 복호화한다.
+URL[] classURLs = new URL[] { new URL(""http://filesave.com/download/util.jar"") };
+URLConnection conn = classURLs.openConnection();
+InputStream is = conn.getInputStream();
+// 입력 스트림을 jarFile명으로 파일을 출력한다.
+ FileOutputStream fos = new FileOutputStream(new File(jarFile));
+ While (is.read(buf) != -1) {
+ ......
+}
+byte[] loadFile = FileManager.getBytes(jarFile);
+loadFile = decrypt(loadFile, publicKey);
+// 복호화된 파일을 생성한다.
+FileManager.createFile(loadFile, jarFile);
+URLClassLoader loader = new URLClassLoader(classURLs);
+Class loadedClass = Class.forName(""MyClass"", true, loader);"
+C#,보안기능,무결성 검사 없는 코드 다운로드,"소스코드 또는 실행파일을 무결성 검사 없이 다운로드 받아 실행하는 경우, 공격자의 악의적인 코드가 실행 가능한 보안약점","public override bool DownloadFile()
+ {
+ var url = ""https://www.somewhere.untrusted.com"";
+ var desDir = ""D:/DestinationPath"";
+ string fileName = Path.GetFileName(url);
+ string descFilePath = Path.Combine(desDir, fileName);
+ try
+ {
+ WebRequest myre = WebRequest.Create(url);
+ }
+ catch (Exception ex)
+ {
+ throw new Exception(ex.Message);
+ }
+ try
+ {
+ byte[] fileData;
+// 파일 무결성 검사 없이 다운로드
+ using (WebClient client = new WebClient())
+ {
+ fileData = client.DownloadData(url);
+ }
+ using (FileStream fs = new FileStream(descFilePath, FileMode.OpenOrCreate))
+ {
+ fs.Write(fileData, 0, fileData.Length);
+ }
+ return true;
+ }
+ catch (Exception ex)
+ {
+ throw new Exception(ex.Message);
+ }
+ }","public override bool DownloadFile()
+ {
+ var url = ""https://www.somewhere.untrusted.com"";
+ var desDir = ""D:/DestinationPath"";
+ string fileName = Path.GetFileName(url);
+ string descFilePath = Path.Combine(desDir, fileName);
+ try
+ {
+ WebRequest myre = WebRequest.Create(url);
+ }
+ catch (Exception ex)
+ {
+ throw new Exception(ex.Message);
+ }
+ try
+ {
+ byte[] fileData;
+ using (WebClient client = new WebClient())
+ {
+ fileData = client.DownloadData(url);
+ }
+// 해쉬 값 등을 사용하여 다운로드 받은 파일 무결성 검사
+ CheckIntegrity(fileData);
+ using (FileStream fs = new FileStream(descFilePath,
+FileMode.OpenOrCreate))
+ {
+ fs.Write(fileData, 0, fileData.Length);
+ }
+ return true;
+ }
+ catch (Exception ex)
+ {
+ throw new Exception(ex.Message);
+ }
+ }"
+C,보안기능,무결성 검사 없는 코드 다운로드,"소스코드 또는 실행파일을 무결성 검사 없이 다운로드 받아 실행하는 경우, 공격자의 악의적인 코드가 실행 가능한 보안약점","void foo() {
+ /* ... */
+ hFile = CreateFile((LPCWSTR)data,GENERIC_WRITE, 0, NULL,
+ CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+ InternetQueryDataAvailable(m_hURL, &dwSize,0,0);
+ InternetReadFile(m_hURL, lpBuffer, dwSize, &dwRead);
+ WriteFile(hFile, lpBuffer, dwRead, &dwWritten, NULL);
+ /* ... */","void foo() {
+ /* ... */
+ hFile = CreateFile((LPCWSTR)data,GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
+ FILE_ATTRIBUTE_NORMAL, NULL);
+ InternetQueryDataAvailable(m_hURL, &dwSize,0,0);
+ bool result = InternetReadFile(m_hURL, lpBuffer, dwSize, &dwRead);
+ if, lp( result == true) {
+ WriteFile(hFileBuffer, dwRead, &dwWritten, NULL);
+ }
+ /* ... */
+ }"
+JAVA,보안기능,반복된 인증시도 제한 기능 부재,인증 시도 수를 제한하지 않아 공격자가 반복적으로 임의 값을 입력하여 계정 권한을 획득 가능한 보안약점,"private static final String SERVER_IP = ""127.0.0.1"";
+ private static final int SERVER_PORT = 8080;
+ private static final int FAIL = -1;
+ public void login() {
+ String username = null;
+ String password = null;
+ Socket socket = null;
+ int result = FAIL;
+ try {
+ socket = new Socket(SERVER_IP, SERVER_PORT);
+ //인증 실패에 대해 제한을 두지 않아 안전하지 않다.
+ while (result == FAIL) {
+ ...
+ result = verifyUser(username, password);
+ }","private static final String SERVER_IP = ""127.0.0.1"";
+private static final int SERVER_PORT = 8080;
+private static final int FAIL = -1;
+private static final int MAX_ATTEMPTS = 5;
+public void login() {
+ String username = null;
+ String password = null;
+ Socket socket = null;
+ int result = FAIL;
+ int count = 0;
+ try {
+ socket = new Socket(SERVER_IP, SERVER_PORT);
+ // 인증 실패 및 시도 횟수에 제한을 두어 안전하다.
+ while (result == FAIL && count < MAX_ATTEMPTS) {
+ ...
+ result = verifyUser(username, password);
+ count++;
+}"
+C,보안기능,반복된 인증시도 제한 기능 부재,인증 시도 수를 제한하지 않아 공격자가 반복적으로 임의 값을 입력하여 계정 권한을 획득 가능한 보안약점,"int validateUser(char *host, int port) {
+ int socket = openSocketConnection(host, port);
+ if (socket < 0) {
+ printf(""Unable to open socket connection"");
+ return(FAIL);
+ }
+ int isValidUser = 0;
+ char nm[NAME_SIZE];
+ char pw[PSWD_SIZE];
+ // 인증시도 횟수를 제한하고 있지 않다.
+ while (isValidUser==0) {
+     if (getNextMsg(socket, nm, NAME_SIZE) > 0) {
+ if (getNextMsg(socket, pw, PSWD_SIZE) > 0) {
+ isValidUser = AuthenticateUser(nm, pw);
+ }
+ }
+ }
+ return(SUCCESS);
+}","#define MAX_ATTEMPTS 5
+
+int validateUser(char *host, int port) {
+ ......
+ // 연속적인 사용자 인증 시도에 대한 횟수를 제한
+ int count = 0;
+ while ((isValidUser==0) && (count<MAX_ATTEMPTS)) {
+ if (getNextMsg(socket, nm, NAME_SIZE) > 0) {
+ if (getNextMsg(socket, pw, PSWD_SIZE) > 0) {
+ isValidUser = AuthenticateUser(nm, pw);
+ }
+ }
+ count++;
+ }
+ if (isValidUser) {
+ return(SUCCESS);
+ } else {
+ return(FAIL);
+ }
+}"
+C#,보안기능,반복된 인증시도 제한 기능 부재,인증 시도 수를 제한하지 않아 공격자가 반복적으로 임의 값을 입력하여 계정 권한을 획득 가능한 보안약점,"// 로그인 실패 시 아무런 제약이 없음
+override protected void OnLoginError(EventArgs e)
+{
+ //do nothing
+}","override protected void OnLoginError(EventArgs e)
+ {
+ // 연속적인 사용자 인증 시도에 대한 횟수를 제한
+ if(ViewState[""LoginErrors""] == null)
+ ViewState[""LoginErrors""] = 0;
+ int ErrorCount = (int)ViewState[""LoginErrors""] + 1;
+ ViewState[""LoginErrors""] = ErrorCount;
+
+ if((ErrorCount > 3) && Login1.PasswordRecoveryUrl !=
+ string.Empty)
+ Response.Redirect(Login1.PasswordRecoveryUrl);
+ }"
+JAVA,시간 및 상태,경쟁조건: 검사시점과 사용시점(TOCTOU),멀티 프로세스 상에서 자원을 검사하는 시점과 사용하는 시점이 달라서 발생하는 보안약점,"class FileMgmtThread extends Thread {
+    private String manageType = """";
+    public FileMgmtThread (String type) {
+    manageType = type;
+    }
+    // 멀티쓰레드 환경에서 공유자원에 여러프로세스가 사용하여 동시에 접근할 가능성이 있어 안전
+    하지 않다.
+    public void run() {
+    try {
+    if (manageType.equals(""READ"")) {
+    File f = new File(""Test_367.txt"");
+    if (f.exists()) {
+    BufferedReader br
+    = new BufferedReader(new FileReader(f));
+    br.close();
+    }
+    } else if (manageType.equals(""DELETE"")) {
+    File f = new File(""Test_367.txt"");
+    if (f.exists()) {
+    f.delete();
+    } else { … }
+    }
+    } catch (IOException e) { … }
+    }
+    }
+    public class CWE367 {
+    public static void main (String[] args) {
+    FileMgmtThread fileAccessThread = new FileMgmtThread(""READ"");
+    FileMgmtThread fileDeleteThread = new FileMgmtThread(""DELETE"");
+// 파일의 읽기와 삭제가 동시에 수행되어 안전하지 않다.
+fileAccessThread.start();
+fileDeleteThread.start();
+}
+}","class FileMgmtThread extends Thread {
+    private static final String SYNC = ""SYNC"";
+    private String manageType = """";
+    public FileMgmtThread (String type) {
+    manageType = type;
+    }
+    public void run() {
+    // 멀티쓰레드 환경에서 synchronized를 사용하여 동시에 접근할 수 없도록 사용해야한다.
+    synchronized(SYNC) {
+    try {
+    if (manageType.equals(""READ"")) {
+    File f = new File(""Test_367.txt"");
+    if (f.exists()) {
+    BufferedReader br
+    = new BufferedReader(new FileReader(f));
+    br.close();
+    }
+    } else if (manageType.equals(""DELETE"")) {
+    File f = new File(""Test_367.txt"");
+    if (f.exists()) {
+    f.delete();
+    } else { … }
+    }
+    } catch (IOException e) { … }
+    }
+    }
+    }
+    public class CWE367 {
+    public static void main (String[] args) {
+    FileMgmtThread fileAccessThread = new FileMgmtThread(""READ"");
+    FileMgmtThread fileDeleteThread = new FileMgmtThread(""DELETE"");
+    fileAccessThread.start();
+    fileDeleteThread.start();
+    }
+    }"
+C#,시간 및 상태,경쟁조건: 검사시점과 사용시점(TOCTOU),멀티 프로세스 상에서 자원을 검사하는 시점과 사용하는 시점이 달라서 발생하는 보안약점,"// 멀티쓰레드 환경에서 동시에 접근할 수 없도록 사용해야한다.
+public void ReadFile(String f)
+{
+if(File.Exists(f))
+ {
+ File.ReadAllLines(f);
+ }
+}","// 멀티쓰레드 환경에서 동시에 접근할 수 없도록 사용해야한다.
+[MethodImpl(MethodImplOptions.Synchronized)]
+public void ReadFile(String f)
+{
+    if(File.Exists(f))
+{
+File.ReadAllLines(f);
+}
+}"
+C,시간 및 상태,경쟁조건: 검사시점과 사용시점(TOCTOU),멀티 프로세스 상에서 자원을 검사하는 시점과 사용하는 시점이 달라서 발생하는 보안약점,"static volatile double account;
+void deposit(int amount) {
+// lock 없이 공유 자원에 접근
+account += amount;
+}
+void withdraw(int amount) {
+account -= amount;
+}","static volatile double account;
+static mtx_t account_lock;
+void deposit(int amount) {
+// mutex_lock, mutex_unlock을 이용해 공유 자원 접근을 제한한다.
+mutex_lock(&account_lock);
+account += amount;
+mutex_unlock(&account_lock);
+}
+void withdraw(int amount) {
+mutex_lock(&account_lock);
+account -= amount;
+mutex_unlock(&account_lock);
+}"
+C,시간 및 상태,종료되지 않는 반복문 또는 재귀함수,종료조건 없는 제어문 사용으로 반복문 또는 재귀함수가 무한히 반복되어 발생할 수 있는 보안약점,"#include <stdio.h>
+int factorial(int i)
+{
+// 재귀함수 탈출 조건을 설정하지 않아 무한루프가 된다.
+return i * factorial(i - 1);
+}
+int main()
+{
+int num = 5;
+int result = factorial(num);
+printf(""%d! : %d\n"", num, result);
+return 0;
+}","#include <stdio.h>
+int factorial(int I)
+{
+// 재귀함수 사용 시에는 아래와 같이 탈출 조건을 사용해야 한다.
+if (i <= 1) {
+return 1;
+}
+return i * factorial(i – 1);
+}
+int main()
+{
+int num = 5;
+int result = factorial(num);
+printf(""%d! : %d\n"", num, result);
+return 0;
+}"
+JAVA,에러처리,오류 메시지 정보노출,"오류메시지나 스택정보에 시스템 내부구조가 포함되어 민감한 정보, 디버깅 정보가 노출 가능한 보안약점","try {
+rd = new BufferedReader(new FileReader(new File(filename)));
+} catch(IOException e) {
+// 에러 메시지로 스택 정보가 노출됨
+e.printStackTrace();
+}","try {
+rd = new BufferedReader(new FileReader(new File(filename)));
+} catch(IOException e) {
+// 에러 코드와 정보를 별도로 정의하고 최소 정보만 로깅
+logger.error(""ERROR-01: 파일 열기 에러"");
+}"
+JAVA,에러처리,오류 메시지 정보노출,"오류메시지나 스택정보에 시스템 내부구조가 포함되어 민감한 정보, 디버깅 정보가 노출 가능한 보안약점","catch(IOException e) {
+// 오류발생시 화면에 출력된 시스템 정보로 다른 공격의 빌미를 제공한다.
+System.err.print(e.getMessage());
+}","try {
+rd = new BufferedReader(new FileReader(new File(filename)));
+} catch(IOException e) {
+// 에러 코드와 정보를 별도로 정의하고 최소 정보만 로깅
+logger.error(""ERROR-01: 파일 열기 에러"");
+}"
+C#,에러처리,오류 메시지 정보노출,"오류메시지나 스택정보에 시스템 내부구조가 포함되어 민감한 정보, 디버깅 정보가 노출 가능한 보안약점","try
+{
+//do something
+}
+catch (CustomException e)
+{
+Console.WriteLine(e);
+}","try
+{
+//do something
+}
+catch (CustomException e)
+{
+_log.Debug(“ERROR-01 : error information”);
+}"
+JAVA,에러처리,오류 상황 대응 부재,시스템 오류상황을 처리하지 않아 프로그램 실행정지 등 의도하지 않은 상황이 발생 가능한 보안약점,"protected Element createContent(WebSession s) {
+……
+try {
+username = s.getParser().getRawParameter(USERNAME);
+password = s.getParser().getRawParameter(PASSWORD);
+if (!""webgoat"".equals(username) || !password.equals(""webgoat"")) {
+s.setMessage(""Invalid username and password entered."");
+return (makeLogin(s));
+}
+} catch (NullPointerException e) {
+// 요청 파라미터에 PASSWORD가 존재하지 않을 경우 Null Pointer Exception이 발생하고
+해당 오류에 대한 대응이 존재하지 않아 인증이 된 것으로 처리
+}","protected Element createContent(WebSession s) {
+……
+try {
+username = s.getParser().getRawParameter(USERNAME);
+password = s.getParser().getRawParameter(PASSWORD);
+if (!""webgoat"".equals(username) || !password.equals(""webgoat"")) {
+s.setMessage(""Invalid username and password entered."");
+return (makeLogin(s));
+}
+} catch (NullPointerException e) {
+// 예외 사항에 대해 적절한 조치를 수행하여야 한다.
+s.setMessage(e.getMessage());
+return (makeLogin(s));
+}"
+C#,에러처리,오류 상황 대응 부재,시스템 오류상황을 처리하지 않아 프로그램 실행정지 등 의도하지 않은 상황이 발생 가능한 보안약점,"try {
+InvokeMtd();
+} catch (CustomException e) {
+// 예외 상황에 대한 대응 부재
+}","try {
+InvokeMtd();
+} catch (CustomException e) {
+// 예외 상황에 대해 적절한 조치를 수행하여야 한다.
+logger.Debug(“log message”);
+}"
+JAVA,에러처리,부적절한 예외 처리, 예외사항을 부적절하게 처리하여 의도하지 않은 상황이 발생 가능한 보안약점,"try {
+    ...
+    reader = new BufferedReader(new InputStreamReader(url.openStream()));
+    String line = reader.readLine();
+    SimpleDateFormat format = new SimpleDateFormat(""MM/DD/YY"");
+    Date date = format.parse(line);
+    // 예외처리를 세분화 할 수 있음에도 광범위하게 사용하여 예기치 않은 문제가 발생 할 수 있다.
+    } catch (Exception e) {
+    System.err.println(""Exception : "" + e.getMessage());
+    }","try {
+...
+reader = new BufferedReader(new InputStreamReader(url.openStream()));
+String line = reader.readLine();
+SimpleDateFormat format = new SimpleDateFormat(""MM/DD/YY"");
+Date date = format.parse(line);
+// 발생할 수 있는 오류의 종류와 순서에 맞춰서 예외처리 한다.
+} catch (MalformedURLException e) {
+System.err.println(""MalformedURLException : "" + e.getMessage());
+} catch (IOException e) {
+System.err.println(""IOException : "" + e.getMessage());
+} catch (ParseException e) {
+System.err.println(""ParseException : "" + e.getMessage());
+}"
+C#,에러처리,부적절한 예외 처리, 예외사항을 부적절하게 처리하여 의도하지 않은 상황이 발생 가능한 보안약점,"try {
+InvokeMtd();
+// 예외처리를 세분화할 수 있음에도 광범위하게 사용하여 예기치 않은 문제가 발생할 수 있다.
+} catch (Exception e) {
+}","try {
+InvokeMtd();
+// 발생할 수 있는 오류의 종류와 순서에 맞춰서 예외처리 한다.
+} catch (IOException e) {
+logger.Debug(“IOException log here”);
+} catch (SQLException e){
+logger.Debug(“SQLException log here”);
+}"
+JAVA,코드오류,Null Pointer 역참조,변수의 주소 값이 Null인 객체를 참조하는 보안약점,"public static int cardinality (Object obj, final Collection col) {
+    int count = 0;
+    if (col == null) {
+    return count;
+    }
+    Iterator it = col.iterator();
+    while (it.hasNext()) {
+        Object elt = it.next();
+// obj가 null이고 elt가 null이 아닐 경우, Null.equals 가 되어 널(Null) 포인터 역참조가 발생한다.
+    if ((null == obj && null == elt) || obj.equals(elt)) {
+    count++;
+    }
+    }
+    return count;
+    }","public static int cardinality (Object obj, final Collection col) {
+    int count = 0;
+    if (col == null) {
+    return count;
+    }
+    Iterator it = col.iterator();
+    while (it.hasNext()) {
+    Object elt = it.next();
+    // obj를 참조하는 equals가 null이
+    if ((null == obj && null == elt) || (null != obj && obj.equals(elt))) {
+    count++;
+    }
+    }
+    return count;
+    }"
+JAVA,코드오류,Null Pointer 역참조,변수의 주소 값이 Null인 객체를 참조하는 보안약점,"String url = reuqest.getParamter(""url"");
+// url 에 null이 들어오면 널(Null) 포인터 역참조가 발생한다.
+if ( url.equals("""") )","String url = reuqest.getParamter(""url"");
+// null값을 가지는 참조 변수를 사용할 경우, null 검사를 수행하고 사용한다.
+if ( url != null || url.equals("""") )"
+C#,코드오류,Null Pointer 역참조,변수의 주소 값이 Null인 객체를 참조하는 보안약점,"protected void Page_Load(object sender, EventArgs e) {
+ // url 파라미터에 name 이 없으면 username은 null 값을 가지게 된다.
+ string username = Request.QueryString[“name”];
+ // null 값을 가지는 username을 참조하여 널(Null) 포인터 역참조가 발생한다.
+ if (username.Length > 20) {
+ // length error
+ }
+}","protected void Page_Load(object sender, EventArgs e) {
+// url 파라미터에 name 이 없으면 username은 null 값을 가지게 된다.
+ string username = Request.QueryString[“name”];
+// null 값을 가지는 username을 참조하기 전에 null 검사를 수행하므로 안전하다.
+if ( username != null && username > 20) {
+// length error
+}
+}"
+C,코드오류,Null Pointer 역참조,변수의 주소 값이 Null인 객체를 참조하는 보안약점,"void NullPointerDereference(int count) {
+ // IntegerAddressReturn()이 0을 return 하면 p는 null 값을 가지게 된다.
+ int *p = IntegerAddressReturn();
+ // null 값을 가지는 p 값을 참조하여 널(Null) 포인터 역참조가 발생한다.
+ *p = count;
+}","void NullPointerDereference(int count) {
+// IntegerAddressReturn()이 0을 return 하면 p는 null 값을 가지게 된다.
+int *p = IntegerAddressReturn();
+// 참조하기전에 null 검사를 수행하므로 안전하다.
+If(p != 0) *p = count;"
+JAVA,코드오류,부적절한 자원 해제,사용 완료된 자원을 해제하지 않아 자원이 고갈되어 새로운 입력을 처리할 수 없는 보안약점,"InputStream in = null;
+OutputStream out = null;
+ try {
+ in = new FileInputStream(inputFile);
+ out = new FileOutputStream(outputFile);
+ ...
+ FileCopyUtils.copy(fis, os);
+ // 자원반환 실행 전에 오류가 발생할 경우 자원이 반환되지 않으며, 할당된 모든 자원을 반환해야
+한다.
+ in.close();
+ out.close();
+} catch (IOException e) {
+ logger.error(e);
+}","InputStream in = null;
+OutputStream out = null;
+try {
+in = new FileInputStream(inputFile);
+out = new FileOutputStream(outputFile);
+...
+FileCopyUtils.copy(fis, os);
+} catch (IOException e) {
+logger.error(e);
+// 항상 수행되는 finally 블록에서 할당받은 모든 자원에 대해 각각 null검사를 수행 후 예외처리를
+하여 자원을 해제하여야 한다.
+} finally {
+if (in != null) {
+try {
+in.close();
+} catch (IOException e) {
+logger.error(e);
+}
+}
+if (out != null) {
+try {
+out.close();
+} catch (IOException e) {
+logger.error(e);
+}
+}
+}"
+C#,코드오류,부적절한 자원 해제,사용 완료된 자원을 해제하지 않아 자원이 고갈되어 새로운 입력을 처리할 수 없는 보안약점,"public void FileStreamTest()
+{
+// fsSource에 자원이 할당되었으나 해제되지 않는다.
+FileStream fsSource = new FileStream(pathSource, FileMode.Open, FileAccess.Read);
+byte[] bytes = new byte[fsSource.Length];
+int numBytesToRead = (int)fsSource.Length;
+int numBytesRead = 0;
+while(numBytesToRead > 0)
+{
+int n = fsSource.Read(bytes, numBytesRead, numBytesToRead);
+if(n==0)
+break;
+numBytesToRead += n;
+numBytesToRead -= n;
+}
+using(FileStream fsNew = new FileStream(pathNew, FileMode.Create, FileAccess.Write))
+{ /* OK */
+fsNew.Write(bytes, 0, numBytesToRead);
+}
+}","public void FileStreamTest()
+{
+// using 구문으로 자원을 할당하면 구문이 끝나는 지점에서 자동으로 자원이 해제된다.
+using(FileStream fsSource = new FileStream(pathSource, FileMode.Open,
+FileAccess.Read)){
+byte[] bytes = new byte[fsSource.Length];
+int numBytesToRead = (int)fsSource.Length;
+int numBytesRead = 0;
+while(numBytesToRead > 0)
+{
+int n = fsSource.Read(bytes, numBytesRead, numBytesToRead);
+if(n==0)
+break;
+numBytesToRead += n;
+numBytesToRead -= n;
+}
+}
+using(FileStream fsNew = new FileStream(pathNew, FileMode.Create,
+FileAccess.Write)) { /* OK */
+fsNew.Write(bytes, 0, numBytesToRead);
+}
+}"
+C,코드오류,부적절한 자원 해제,사용 완료된 자원을 해제하지 않아 자원이 고갈되어 새로운 입력을 처리할 수 없는 보안약점,"void ImproperResourceRelease(char* filename) {
+char buf[BUF_SIZE];
+FILE *f = fopen(filename, “r”);
+if(!checkSomething()) {
+printf(“Something is wrong”);
+return;
+}
+// checkSomething에서 false를 반환하는 경우, 파일 핸들러를 종료할 수 없다.
+fclose(f);
+}","void ImproperResourceRelease(char* filename) {
+char buf[BUF_SIZE];
+FILE *f = fopen(filename, “r”);
+if(!checkSomething()) {
+printf(“Something is wrong”);
+// checkSomthing에서 false를 반환해도 파일 핸들러를 종료하도록 수정
+fclose(f);
+return;
+ }
+fclose(f);
+}"
+C,코드오류,해제된 자원 사용,메모리 등 해제된 자원을 참조하여 예기치 않은 오류가 발생하는 보안약점,"int main(int argc, const char *argv[]) {
+char *temp;
+temp = (char *)malloc(BUFFER_SIZE);
+……
+free(temp);
+// 해제한 자원을 사용하고 있어 의도하지 않은 결과가 발생하게 된다.
+stmcpy(temp, argv[1], BUFFER_SIZE-1);
+}","int main(int argc,const char *argv[]) {
+char *temp;
+temp = (char *)malloc(BUFFER_SIZE);
+……
+// 할당된 자원을 최종적으로 사용하고 해제하여야 한다.
+stmcpy(temp,argv[1], BUFFER_SIZE-1);
+free(temp);
+}"
+C,코드오류,해제된 자원 사용,메모리 등 해제된 자원을 참조하여 예기치 않은 오류가 발생하는 보안약점,"char *data;
+int data_type
+if (data_type==val_1) { free(data); }
+……
+// 이미 해제된 자원을 이중 해제하여 문제가 발생한다.
+if (data_type==val_2) { free(data); }","char *data;
+int data_type
+if (data_type==val_1) {
+free(data);
+// 메모리를 해제한 후 항상 포인터에 NULL을 할당하여 이중 해제하더라도 무시되게 한다.
+data = NULL;
+}
+……
+if (data_type==val_2) {
+free(data);
+// 메모리를 해제한 후 항상 포인터에 NULL을 할당하여 이중 해제하더라도 무시되게 한다.
+data = NULL;
+}"
+C,코드오류,초기화되지 않은 변수 사용,변수를 초기화하지 않고 사용하여 예기치 않은 오류가 발생하는 보안약점,"// 변수의 초기값을 지정하지 않을 경우 공격에 사용 될 수 있어 안전하지 않다.
+int x, y;
+switch(position) {
+case 0: x = base_position; y = base_position beak;
+case 1: x = base_position + i; y = base_position - i break;
+default: x=1; break;
+}
+setCursorPosition(x,y);","// 변수의 초기값은 항상 지정하여야 한다.
+int x=1, y=1;
+switch(position) {
+case 0: x = base_position; y = base_position beak;
+case 1: x = base_position + i; y = base_position - i break;
+default: x=1; break;
+}
+setCursorPosition(x,y);"
+JAVA,코드오류,신뢰할 수 없는 데이터의 역직렬화,"악의적인 코드가 삽입·수정된 직렬화 데이터를 적절한 검증 없이 역직렬화하여 발생하는 보안약점
+* 직렬화: 객체를 전송 가능한 데이터형식으로 변환
+* 역직렬화: 직렬화된 데이터를 원래 객체로 복원","public static void main(String[] args) throws
+IOException, GeneralSecurityException, ClassNotFoundException {
+....
+// map을 역직렬화 한다.
+ObjectInputStream in = new ObjectInputStream(new FileInputStream(""data""));
+sealedMap = (SealedObject) in.readObject();
+in.close();
+// 객체를 추출한다.
+cipher = Cipher.getInstance(""AES"");
+cipher.init(Cipher.DECRYPT_MODE, key);
+signedMap = (SignedObject) sealedMap.getObject(cipher);
+// 서명값 검증 과정에서 불일치 시 예외를 리턴하고, 일치 시 map 값을 읽는다.
+if (!signedMap.verify(kp.getPublic(), sig)) {
+throw new GeneralSecurityException(""Map failed verification"");
+}
+map = (SerializableMap<String, Integer>) signedMap.getObject();
+}","public static void main(String[] args) throws
+IOException, GeneralSecurityException, ClassNotFoundException {
+....
+// map을 역직렬화 한다.
+ObjectInputStream in = new ObjectInputStream(new FileInputStream(""data""));
+sealedMap = (SealedObject) in.readObject();
+in.close();
+// 객체를 추출한다.
+cipher = Cipher.getInstance(""AES"");
+cipher.init(Cipher.DECRYPT_MODE, key);
+signedMap = (SignedObject) sealedMap.getObject(cipher);
+// 서명값 검증 과정에서 불일치 시 예외를 리턴하고, 일치 시 map 값을 읽는다.
+if (!signedMap.verify(kp.getPublic(), sig)) {
+throw new GeneralSecurityException(""Map failed verification"");
+}
+map = (SerializableMap<String, Integer>) signedMap.getObject();
+}"
+JAVA,코드오류,신뢰할 수 없는 데이터의 역직렬화,"악의적인 코드가 삽입·수정된 직렬화 데이터를 적절한 검증 없이 역직렬화하여 발생하는 보안약점
+* 직렬화: 객체를 전송 가능한 데이터형식으로 변환
+* 역직렬화: 직렬화된 데이터를 원래 객체로 복원","class DeserializeExample {
+public static Object deserialize(byte[] buffer)
+throws IOException, ClassNotFoundException {
+Object ret = null;
+try (ByteArrayInputStream bais = new ByteArrayInputStream(buffer)) {
+try (ObjectInputStream ois = new ObjectInputStream(bais)) {
+ret = ois.readObject();
+}
+}
+return ret;
+}
+}","public class WhitelistedObjectInputStream extends ObjectInputStream {
+public Set<String> whitelist;
+// WhilelistedObjectInputStream을 생성할 때 화이트리스트를 입력받는다.
+public WhitelistedObjectInputStream(InputStream inputStream, Set<String> wl)
+throws IOException {
+super(inputStream);
+whitelist = wl;
+}
+@Override
+protected Class<?> resolveClass(ObjectStreamClass cls) throws IOException,
+ClassNotFoundException {
+// ObjectStreamClass의 클래스명이 화이트리스트에 있는지 확인한다.
+if (!whitelist.contains(cls.getName())) {
+throw new InvalidClassException(""Unexpected serialized class"", cls.getName());
+}
+return super.resolveClass(cls);
+}
+}
+@RequestMapping(value = ""/upload"", method = RequestMethod.POST)
+public Student upload(@RequestParam(""file"") MultipartFile multipartFile)
+throws ClassNotFoundException, IOException {
+Student student = null;
+File targetFile = new File(""/temp/"" + multipartFile.getOriginalFilename());
+// 역직렬화 대상 클래스 이름의 화이트리스트 생성한다.
+Set<String> whitelist = new HashSet<String>(Arrays.asList(
+new String[] {
+""Student""
+}));
+try (InputStream fileStream = multipartFile.getInputStream()) {
+try (WhitelistedObjectInputStream ois =
+new WhitelistedObjectInputStream(fileStream, whitelist)) {
+// 화이트리스트에 없는 역직렬화 데이터의 경우 예외 발생시킨다.
+student = (Student) ois.readObject();
+}
+}
+return student;
+}"
+JAVA,캡슐화,잘못된 세션에 의한 데이터 정보노출,잘못된 세션에 의해 인가되지 않은 사용자에게 중요정보가 노출 가능한 보안약점,"<%@page import=""javax.xml.namespace.*""%>
+<%@page import=""gov.mogaha.ntis.web.frs.gis.cmm.util.*"" %>
+<%!
+// JSP에서 String 필드들이 멤버 변수로 선언됨
+String username = ""/"";
+String imagePath = commonPath + ""img/"";
+String imagePath_gis = imagePath + ""gis/cmm/btn/"";
+......
+%>","<%@page import=""javax.xml.namespace.*""%>
+<%@page import=""gov.mogaha.ntis.web.frs.gis.cmm.util.*"" %>
+<%
+// JSP에서 String 필드들이 로컬 변수로 선언됨
+String commonPath = ""/"";
+String imagePath = commonPath + ""img/"";
+String imagePath_gis = imagePath + ""gis/cmm/btn/"";
+......
+%>"
+JAVA,캡슐화,잘못된 세션에 의한 데이터 정보노출,잘못된 세션에 의해 인가되지 않은 사용자에게 중요정보가 노출 가능한 보안약점,"/*
+ * @Controller
+ * public class TrendForecastController {
+ * // Controller에서 int 필드가 멤버 변수로 선언되어 스레드간에 공유됨
+ * private int currentPage = 1;
+ * 
+ * public void doSomething(HttpServletRequest request) {
+ * currentPage = Integer.parseInt(request.getParameter(""page""));
+ * }......
+ * }
+ */","/*
+ * @Controller
+ * public class TrendForecastController {
+ * public void doSomething(HttpServletRequest request) {
+ * // 지역변수로 사용하여 스레드간 공유되지 못하도록 한다.
+ * int currentPage = Integer.parseInt(request.getParameter(""page""));
+ * }......
+ * }
+ */"
+C#,캡슐화,잘못된 세션에 의한 데이터 정보노출,잘못된 세션에 의해 인가되지 않은 사용자에게 중요정보가 노출 가능한 보안약점,"class DataLeakBetweenSessions : IHttpHandler
+{
+// 다중 스레드 환경에서 IHttpHandler 를 구현하는 클래스에 정보를 저장하는 필드가 포함되면
+안된다.
+private String id;
+public void ProcessRequest(HttpContext ctx)
+{
+var json = new JSONResonse()
+{
+Success = ctx.Request.QueryString[""name""] != null,
+Name = ctx.Request.QueryString[""name""]
+};
+ctx.Response.ContentType = ""application/json"";
+ctx.Response.Write(JsonConvert.SerializeObject(json));
+}
+public bool IsReusable
+{
+get { return false; }
+}
+}","class DataLeakBetweenSessions : IHttpHandler
+{
+public void ProcessRequest(HttpContext ctx)
+{
+// 지역변수나 세션변수를 선언해서 사용해야한다.
+ctx.Session[""id""] = ctx.Request.QueryString[""id""];
+ctx.Response.ContentType = ""application/json"";
+ctx.Response.Write(JsonConvert.SerializeObject(json));
+}
+public bool IsReusable
+{
+get { return false; }
+}
+}
+var json = new JSONResonse()
+{
+Success = ctx.Request.QueryString[""name""] != null,
+Name = ctx.Request.QueryString[""name""]
+};"
+JAVA,캡슐화,제거되지 않고 남은 디버그 코드,디버깅을 위한 코드를 제거하지 않아 인가되지 않은 사용자에게 중요정보가 노출 가능한 보안약점,"class Base64 {
+public static void main(String[] args) {
+if (debug) {
+byte[] a = { (byte) 0xfc, (byte) 0x0f, (byte) 0xc0 };
+byte[] b = { (byte) 0x03, (byte) 0xf0, (byte) 0x3f };
+......
+}
+}
+public void otherMethod() { ... }
+}","class Base64 {
+public void otherMethod() { ... }
+}"
+C#,캡슐화,제거되지 않고 남은 디버그 코드,디버깅을 위한 코드를 제거하지 않아 인가되지 않은 사용자에게 중요정보가 노출 가능한 보안약점,"class Example {
+public void Log() {
+// Console.WriteLine 등의 메소드를 사용한 디버그용 코드가 남아있다.
+Console.WriteLine(""sensitive info"");
+}
+}","class Example {
+public void Log() {
+// 디버그용 코드를 삭제해야한다.
+//Console.WriteLine(""sensitive info"");
+}
+}"
+C,캡슐화,제거되지 않고 남은 디버그 코드,디버깅을 위한 코드를 제거하지 않아 인가되지 않은 사용자에게 중요정보가 노출 가능한 보안약점,"void LeftoverDebugCode() {
+int i, ntprs;
+char **strings;
+nptrs = backtrace(buffer, 100);
+strings = backtrace_symbols(buffer, nptrs);
+...
+// 디버그 모드일 시 콜스택을 출력한다.
+if(debug) {
+for(i=0; i < nptr; i++) printf(“%s\n”, strings[j]);
+}
+}","void LeftoverDebugCode() {
+... // 디버그 코드를 삭제하고 동작 코드만 남긴다.
+}"
+JAVA,캡슐화,Public 메소드부터 반환된 Private 배열,Public으로 선언된 메소드에서 Private로 선언된 배열을 반환(return)하면 Private 배열의 주소 값이 외부에 노출되어 해당 Private 배열값을 외부에서 수정 가능한 보안약점,"// private 인 배열을 public인 메소드가 return한다.
+private Color[] colors;
+public Color[] getUserColors(Color[] userColors) { return colors; }","// 안전한 코드의 예 JAVA (배열의 원소가 일반객체일 경우)
+private Color[] colors;
+
+// 메소드를 private으로 하거나, 복제�� 반환, 수정하는 public 메소드를 별도로 만든다.
+public void onCreate(Bundle savedInstanceState) {
+super.onCreate(savedInstanceState);
+Color[] newColors = getUserColors();
+......
+}
+
+public Color[] getUserColors(Color[] userColors) {
+    // 배열을 복사한다.
+    Color[] colors = new Color[userColors.length];
+    for (int i = 0; i < colors.length; i++)
+        // clone()메소드를 이용하여 배열의 원소도 복사한다.
+        colors[i] = this.colors[i].clone();
+    return colors;
+}"
+JAVA,캡슐화,Public 메소드부터 반환된 Private 배열,Public으로 선언된 메소드에서 Private로 선언된 배열을 반환(return)하면 Private 배열의 주소 값이 외부에 노출되어 해당 Private 배열값을 외부에서 수정 가능한 보안약점,"// private 인 배열을 public인 메소드가 return한다.
+private String[] colors;
+public String[] getColors() { return colors; }","// 안전한 코드의 예 JAVA (배열의 원소가 String 타입 등과 같이 수정이 되지 않는 경우)
+private String[] colors;
+
+// 메소드를 private으로 하거나, 복제본 반환, 수정하는 public 메소드를 별도로 만든다.
+public void onCreate(Bundle savedInstanceState) {
+super.onCreate(savedInstanceState);
+String[] newColors = getColors();
+......
+}
+
+public String[] getColors() {
+    String[] ret = null;
+    if (this.colors != null) {
+        ret = new String[colors.length];
+        for (int i = 0; i < colors.length; i++) {
+            ret[i] = this.colors[i];
+        }
+    }
+    return ret;
+}"
+C#,캡슐화,Public 메소드부터 반환된 Private 배열,Public으로 선언된 메소드에서 Private로 선언된 배열을 반환(return)하면 Private 배열의 주소 값이 외부에 노출되어 해당 Private 배열값을 외부에서 수정 가능한 보안약점,"// private 인 collection을 public인 메소드가 return한다.
+private List<Color> colors;
+public List<Color> getUserColors() { return colors; }","private List<Color> colors;
+// 메소드를 private으로 하거나, 복제본 반환, 수정하는 public 메소드를 별도로 만든다.
+public List<Color> getUserColors() {
+// 배열을 복사한다.
+List< ICloneable> newList = new List< ICloneable>(colors.Count);
+//Clone()메소드를 이용하여 collection의 원소도 복사한다.
+colors.ForEach((item) =>
+{
+newList.Add((ICloneable)item.Clone());
+});
+return newList;
+}"
+JAVA,캡슐화,Private 배열에 Public 데이터 할당,Public으로 선언된 데이터 또는 메소드의 인자가 Private으로 선언된 배열에 저장되면 이 Private 배열을 외부에서 접근하여 수정 가능한 보안약점,"// userRoles 필드는 private이지만, public인 setUserRoles()로 외부의 배열이 할당되면,
+사실상 public 필드가 된다.
+private UserRole[] userRoles;
+public void setUserRoles(UserRole[] userRoles) {
+this.userRoles = userRoles;
+}","// 안전한 코드의 예 JAVA (배열의 원소가 일반객체일 경우)
+// 객체가 클래스의 private member를 수정하지 않도록 한다.
+private UserRole[] userRoles;
+
+public void setUserRoles(UserRole[] userRoles) {
+    this.userRoles = new UserRole[userRoles.length];
+    for (int i = 0; i < userRoles.length; ++i)
+        this.userRoles[i] = userRoles[i].clone();
+}"
+JAVA,캡슐화,Private 배열에 Public 데이터 할당,Public으로 선언된 데이터 또는 메소드의 인자가 Private으로 선언된 배열에 저장되면 이 Private 배열을 외부에서 접근하여 수정 가능한 보안약점,"// userRoles 필드는 private이지만, public인 setUserRoles()로 외부의 배열이 할당되면,
+사실상 public 필드가 된다.
+private String[] userRoles;
+public void setUserRoles(String[] userRoles) {
+this.userRoles = userRoles;
+}","// 안전한 코드의 예 (배열의 원소가 String 타입 등과 같이 수정이 되지 않는 경우)
+// 객체가 클래스의 private member를 수정하지 않도록 한다.
+private String[] userRoles;
+
+public void setUserRoles(String[] userRoles) {
+    this.userRoles = new String[userRoles.length];
+    for (int i = 0; i < userRoles.length; ++i)
+        this.userRoles[i] = userRoles[i];
+}"
+C#,캡슐화,Private 배열에 Public 데이터 할당,Public으로 선언된 데이터 또는 메소드의 인자가 Private으로 선언된 배열에 저장되면 이 Private 배열을 외부에서 접근하여 수정 가능한 보안약점,"class Program
+{
+// userRoles 필드는 private이지만, public인 setUserRoles()으로 외부의 배열이 할당되면,
+사실상 public 필드가 된다.
+private String[] userRoles;
+public void SetUserRoles(String[] userRoles)
+{
+this.userRoles = userRoles;
+}
+}","class Program
+{
+// 객체가 클래스의 private member를 수정하지 않도록 한다.
+private String[] userRoles;
+public void SetUserRoles(String[] userRoles)
+{
+int length = userRoles.Length;
+this.userRoles = new String[length];
+for(int i = 0; i < length; i++) { \
+this.userRoles[i] = userRoles[i];
+}
+}
+}"
+JAVA,API 오용,DNS lookup에 의존한 보안결정,도메인명 확인(DNS lookup)으로 보안결정을 수행할 때 악의적으로 변조된 DNS 정보로 예기치 않은 보안위협에 노출되는 보안약점,"public void doGet(HttpServletRequest req, HttpServletResponse res)
+throws ServletException, IOException {
+boolean trusted = false;
+String ip = req.getRemoteAddr();
+InetAddress addr = InetAddress.getByName(ip);
+// 도메인은 공격자에 의해 실행되는 서버의 DNS가 변경될 수 있으므로 안전하지 않다.
+if (addr.getCanonicalHostName().endsWith(""trustme.com"")) {
+    do_something_for_Trust_System();
+    }","public void doGet(HttpServletRequest req, HttpServletResponse res)
+throws ServletException, IOException {
+String ip = req.getRemoteAddr();
+if (ip == null || """".equals(ip)) return ;
+// 이용하려는 실제 서버의 IP 주소를 사용하여 DNS변조에 방어한다.
+String trustedAddr = ""127.0.0.1"";
+if (ip.equals(trustedAddr)) {
+do_something_for_Trust_System();
+}"
+C#,API 오용,DNS lookup에 의존한 보안결정,도메인명 확인(DNS lookup)으로 보안결정을 수행할 때 악의적으로 변조된 DNS 정보로 예기치 않은 보안위협에 노출되는 보안약점,"bool trusted;
+string remoteIpAddress = Request.ServerVariables[""REMOTE_HOST""];
+IPAddress hostIPAddress = IPAddress.Parse(remoteIpAddress);
+IPHostEntry hostInfo = Dns.GetHostByAddress(hostIPAddress);
+string hostName = hostInfo.HostName;
+if (hostName.EndsWith(""trust.com""))
+{
+trusted = true;
+}","bool trusted;
+string remoteIpAddress = Request.ServerVariables[""REMOTE_HOST""];
+if ( remoteIpAddress.Equals(trustedAddr))
+{
+trusted = true;
+Do_something_for_Trust_System();
+}"
+C,API 오용,DNS lookup에 의존한 보안결정,도메인명 확인(DNS lookup)으로 보안결정을 수행할 때 악의적으로 변조된 DNS 정보로 예기치 않은 보안위협에 노출되는 보안약점,"struct hostent *hp;struct in_addr myaddr;
+char* tHost = ""trustme.example.com"";
+myaddr.s_addr=inet_addr(ip_addr_string);
+hp = gethostbyaddr((char *) &myaddr, sizeof(struct in_addr), AF_INET);
+// 요청의 신뢰성을 호스트의 이름으로 판별하고 있다.
+if (hp && !strncmp(hp->h_name, tHost, sizeof(tHost))) {
+trusted = true;
+} else {
+trusted = false;
+}","struct hostent *hp;struct in_addr myaddr;
+char* tHost = ""127.0.0.1"";
+myaddr.s_addr=inet_addr(ip_addr_string);
+hp = gethostbyaddr((char *) &myaddr, sizeof(struct in_addr), AF_INET);
+// 호스트의 이름이 아니라 IP로 직접 비교한다.
+if (hp && !strncmp(hp->h_name, tHost, sizeof(tHost))) {
+trusted = true;
+} else {
+trusted = false;
+}"
+C,API 오용,취약한 API 사용,취약한 함수를 사용해서 예기치 않은 보안위협에 노출되는 보안약점,"#include <stdio.h>
+void requestString()
+{
+char str[100];
+// gets() 함수는 문자열 길이를 제한 할 수 없어 안전하지 않다.
+gets(str);
+}","#include <stdio.h>
+void requestString()
+{
+char str[100];
+// gets_s() 함수는 문자열 길이 제한이 가능하다.
+gets_s(str, sizeof(str));
+}"
+JAVA,API 오용,취약한 API 사용,취약한 함수를 사용해서 예기치 않은 보안위협에 노출되는 보안약점,"public class S246 extends javax.servlet.http.HttpServlet {
+private Socket socket
+protected void doGet(HttpServletRequest request,
+HttpServletResponse response) throws ServletException {
+try {
+// 프레임워크의 메소드 호출 대신 소켓을 직접 사용하고 있어 프레임워크에서 제공하는 보안기능을
+제공 받지 못해 안전하지 않다.
+socket = new Socket(""kisa.or.kr"", 8080);
+} catch (UnknownHostException e) {
+......","public class S246 extends javax.servlet.http.HttpServlet {
+protected void doGet(HttpServletRequest request,
+HttpServletResponse response) throws ServletException {
+ObjectOutputStream oos = null;
+ObjectInputStream ois = null;
+try {
+URL url = new URL(""http://127.0.0.1:8080/DataServlet"");
+// 보안기능을 제공하는 프레임워크의 메소드를 사용하여야한다.
+URLConnection urlConn = url.openConnection();
+urlConn.setDoOutput(true);
+......."
+JAVA,API 오용,취약한 API 사용,취약한 함수를 사용해서 예기치 않은 보안위협에 노출되는 보안약점,"public class U382 extends HttpServlet {
+public void doPost(HttpServletRequest request, HttpServletResponse response)
+throws ServletException, IOException {
+try {
+do_something(logger);
+} catch (IOException ase) {
+logger.info(""ERROR"");
+// J2EE 프로그램에서 System.exit()을 사용하여 서비스가 종료 될 수 있다.
+System.exit(1);
+}","public class U382 extends HttpServlet {
+public void doPost(HttpServletRequest request, HttpServletResponse response)
+throws ServletException, IOException {
+try {
+do_something(logger);
+} catch (IOException ase) {
+logger.info(""ERROR"");
+// 서비스 종료를 막기 위해 J2EE에서는 System.exit()를 사용하지 않는다.
+}"
+C#,API 오용,취약한 API 사용,취약한 함수를 사용해서 예기치 않은 보안위협에 노출되는 보안약점,"try {
+...
+} catch (Exception e) {
+...
+// Application.Exit() 은 즉시 프로그램을 종료하기 때문에, Form.Closed 혹은 Form.Closing
+이벤트가 처리되지 않는다.
+Application.Exit();
+}","try {
+...
+} catch (Exception e) {
+...
+// Application.Exit() 을 사용하지 않으면, 이벤트를 처리하지 못하고 프로그램이 종료되는 것을
+방지할 수 있다.
+this.Close();
+}"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),SQL 인젝션 방지,,"import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+ 
+class Login {
+  public Connection getConnection() throws SQLException {
+    DriverManager.registerDriver(new
+            com.microsoft.sqlserver.jdbc.SQLServerDriver());
+    String dbConnection =
+      PropertyManager.getProperty(""db.connection"");
+    // Can hold some value like
+    // ""jdbc:microsoft:sqlserver://<HOST>:1433,<UID>,<PWD>""
+    return DriverManager.getConnection(dbConnection);
+  }
+ 
+  String hashPassword(char[] password) {
+    // Create hash of password
+  }
+ 
+  public void doPrivilegedAction(String username, char[] password)
+                                 throws SQLException {
+    Connection connection = getConnection();
+    if (connection == null) {
+      // Handle error
+    }
+    try {
+      String pwd = hashPassword(password);
+ 
+      String sqlString = ""SELECT * FROM db_user WHERE username = '""
+                         + username +
+                         ""' AND password = '"" + pwd + ""'"";
+      Statement stmt = connection.createStatement();
+      ResultSet rs = stmt.executeQuery(sqlString);
+ 
+      if (!rs.next()) {
+        throw new SecurityException(
+          ""User name or password incorrect""
+        );
+      }
+ 
+      // Authenticated; proceed
+    } finally {
+      try {
+        connection.close();
+      } catch (SQLException x) {
+        // Forward to handler
+      }
+    }
+  }
+}","public void doPrivilegedAction(
+        String username, char[] password) throws SQLException {
+    Connection connection = getConnection();
+    if (connection == null) {
+        // Handle error
+    }
+    try {
+        String pwd = hashPassword(password);
+
+        // Validate username length
+        if (username.length() > 8) {
+            // Handle error
+        }
+
+        String sqlString = ""select * from db_user where username=? and password=?"";
+        PreparedStatement stmt = connection.prepareStatement(sqlString);
+        stmt.setString(1, username);
+        stmt.setString(2, pwd);
+        ResultSet rs = stmt.executeQuery();
+        if (!rs.next()) {
+            throw new SecurityException(""User name or password incorrect"");
+        }
+
+        // Authenticated; proceed
+    } finally {
+        try {
+            connection.close();
+        } catch (SQLException x) {
+            // Forward to handler
+        }
+    }
+}"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),SQL 인젝션 방지,,"import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+class Login {
+    public Connection getConnection() throws SQLException {
+        DriverManager.registerDriver(new com.microsoft.sqlserver.jdbc.SQLServerDriver());
+        String dbConnection = PropertyManager.getProperty(""db.connection"");
+        // Can hold some value like
+        // ""jdbc:microsoft:sqlserver://<HOST>:1433,<UID>,<PWD>""
+        return DriverManager.getConnection(dbConnection);
+    }
+
+    String hashPassword(char[] password) {
+        // Create hash of password
+    }
+
+    public void doPrivilegedAction(
+            String username, char[] password) throws SQLException {
+        Connection connection = getConnection();
+        if (connection == null) {
+            // Handle error
+        }
+        try {
+            String pwd = hashPassword(password);
+            String sqlString = ""select * from db_user where username="" +
+                    username + "" and password ="" + pwd;
+            PreparedStatement stmt = connection.prepareStatement(sqlString);
+
+            ResultSet rs = stmt.executeQuery();
+            if (!rs.next()) {
+                throw new SecurityException(""User name or password incorrect"");
+            }
+
+            // Authenticated; proceed
+        } finally {
+            try {
+                connection.close();
+            } catch (SQLException x) {
+                // Forward to handler
+            }
+        }
+    }
+}","public void doPrivilegedAction(
+        String username, char[] password) throws SQLException {
+    Connection connection = getConnection();
+    if (connection == null) {
+        // Handle error
+    }
+    try {
+        String pwd = hashPassword(password);
+
+        // Validate username length
+        if (username.length() > 8) {
+            // Handle error
+        }
+
+        String sqlString = ""select * from db_user where username=? and password=?"";
+        PreparedStatement stmt = connection.prepareStatement(sqlString);
+        stmt.setString(1, username);
+        stmt.setString(2, pwd);
+        ResultSet rs = stmt.executeQuery();
+        if (!rs.next()) {
+            throw new SecurityException(""User name or password incorrect"");
+        }
+
+        // Authenticated; proceed
+    } finally {
+        try {
+            connection.close();
+        } catch (SQLException x) {
+            // Forward to handler
+        }
+    }
+}"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),유효성 검사 전 문자열 정규화,,"// String s may be user controllable
+// \uFE64 is normalized to < and \uFE65 is normalized to > using the NFKC normalization form
+String s = ""\uFE64"" + ""script"" + ""\uFE65"";
+ 
+// Validate
+Pattern pattern = Pattern.compile(""[<>]""); // Check for angle brackets
+Matcher matcher = pattern.matcher(s);
+if (matcher.find()) {
+  // Found black listed tag
+  throw new IllegalStateException();
+} else {
+  // ...
+}
+ 
+// Normalize
+s = Normalizer.normalize(s, Form.NFKC);","String s = ""\uFE64"" + ""script"" + ""\uFE65"";
+ 
+// Normalize
+s = Normalizer.normalize(s, Form.NFKC);
+ 
+// Validate
+Pattern pattern = Pattern.compile(""[<>]"");
+Matcher matcher = pattern.matcher(s);
+if (matcher.find()) {
+  // Found blacklisted tag
+  throw new IllegalStateException();
+} else {
+  // ...
+}"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),처리되지 않은 사용자 입력 기록하지 않기,,"if (loginSuccessful) {
+  logger.severe(""User login succeeded for: "" + username);
+} else {
+  logger.severe(""User login failed for: "" + username);
+}","
+if(loginSuccessful){logger.severe(""User login succeeded for: ""+sanitizeUser(username));}else{logger.severe(""User login failed for: ""+sanitizeUser(username));}
+
+public String sanitizeUser(String username){return Pattern.matches(""[A-Za-z0-9_]+"",username))?username:""unauthorized user"";}
+
+Logger sanLogger=new SanitizedTextLogger(logger);
+
+if(loginSuccessful){sanLogger.severe(""User login succeeded for: ""+username);}else{sanLogger.severe(""User login failed for: ""+username);}
+
+class SanitizedTextLogger extends Logger {
+    Logger delegate;
+   
+    public SanitizedTextLogger(Logger delegate) {
+      super(delegate.getName(), delegate.getResourceBundleName());
+      this.delegate = delegate;
+    }
+   
+    public String sanitize(String msg) {
+      Pattern newline = Pattern.compile(""\n"");
+      Matcher matcher = newline.matcher(msg);
+      return matcher.replaceAll(""\n  "");
+    }
+   
+    public void severe(String msg) {
+      delegate.severe(sanitize(msg));
+    }
+   
+    // .. Other Logger methods which must also sanitize their log messages
+  }"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),ZipInputStream에서 파일을 안전하게 추출하기,,"static final int BUFFER = 512;
+// ...
+ 
+public final void unzip(String filename) throws java.io.IOException{
+  FileInputStream fis = new FileInputStream(filename);
+  ZipInputStream zis = new ZipInputStream(new BufferedInputStream(fis));
+  ZipEntry entry;
+  try {
+    while ((entry = zis.getNextEntry()) != null) {
+      System.out.println(""Extracting: "" + entry);
+      int count;
+      byte data[] = new byte[BUFFER];
+      // Write the files to the disk
+      FileOutputStream fos = new FileOutputStream(entry.getName());
+      BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);
+      while ((count = zis.read(data, 0, BUFFER)) != -1) {
+        dest.write(data, 0, count);
+      }
+      dest.flush();
+      dest.close();
+      zis.closeEntry();
+    }
+  } finally {
+    zis.close();
+  }
+}","static final int BUFFER = 512;
+static final long TOOBIG = 0x6400000; // Max size of unzipped data, 100MB
+static final int TOOMANY = 1024;      // Max number of files
+// ...
+ 
+private String validateFilename(String filename, String intendedDir)
+      throws java.io.IOException {
+  File f = new File(filename);
+  String canonicalPath = f.getCanonicalPath();
+ 
+  File iD = new File(intendedDir);
+  String canonicalID = iD.getCanonicalPath();
+   
+  if (canonicalPath.startsWith(canonicalID)) {
+    return canonicalPath;
+  } else {
+    throw new IllegalStateException(""File is outside extraction target directory."");
+  }
+}
+ 
+public final void unzip(String filename) throws java.io.IOException {
+  FileInputStream fis = new FileInputStream(filename);
+  ZipInputStream zis = new ZipInputStream(new BufferedInputStream(fis));
+  ZipEntry entry;
+  int entries = 0;
+  long total = 0;
+  try {
+    while ((entry = zis.getNextEntry()) != null) {
+      System.out.println(""Extracting: "" + entry);
+      int count;
+      byte data[] = new byte[BUFFER];
+      // Write the files to the disk, but ensure that the filename is valid,
+      // and that the file is not insanely big
+      String name = validateFilename(entry.getName(), ""."");
+      if (entry.isDirectory()) {
+        System.out.println(""Creating directory "" + name);
+        new File(name).mkdir();
+        continue;
+      }
+      FileOutputStream fos = new FileOutputStream(name);
+      BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);
+      while (total + BUFFER <= TOOBIG && (count = zis.read(data, 0, BUFFER)) != -1) {
+        dest.write(data, 0, count);
+        total += count;
+      }
+      dest.flush();
+      dest.close();
+      zis.closeEntry();
+      entries++;
+      if (entries > TOOMANY) {
+        throw new IllegalStateException(""Too many files to unzip."");
+      }
+      if (total + BUFFER > TOOBIG) {
+        throw new IllegalStateException(""File being unzipped is too big."");
+      }
+    }
+  } finally {
+    zis.close();
+  }
+}"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),ZipInputStream에서 파일을 안전하게 추출하기,,"static final int BUFFER = 512;
+static final int TOOBIG = 0x6400000; // 100MB
+// ...
+ 
+public final void unzip(String filename) throws java.io.IOException{
+  FileInputStream fis = new FileInputStream(filename);
+  ZipInputStream zis = new ZipInputStream(new BufferedInputStream(fis));
+  ZipEntry entry;
+  try {
+    while ((entry = zis.getNextEntry()) != null) {
+      System.out.println(""Extracting: "" + entry);
+      int count;
+      byte data[] = new byte[BUFFER];
+      // Write the files to the disk, but only if the file is not insanely big
+      if (entry.getSize() > TOOBIG ) {
+         throw new IllegalStateException(""File to be unzipped is huge."");
+      }
+      if (entry.getSize() == -1) {
+         throw new IllegalStateException(""File to be unzipped might be huge."");
+      }
+      FileOutputStream fos = new FileOutputStream(entry.getName());
+      BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);
+      while ((count = zis.read(data, 0, BUFFER)) != -1) {
+        dest.write(data, 0, count);
+      }
+      dest.flush();
+      dest.close();
+      zis.closeEntry();
+    }
+  } finally {
+    zis.close();
+  }
+}","static final int BUFFER = 512;
+static final long TOOBIG = 0x6400000; // Max size of unzipped data, 100MB
+static final int TOOMANY = 1024;      // Max number of files
+// ...
+ 
+private String validateFilename(String filename, String intendedDir)
+      throws java.io.IOException {
+  File f = new File(filename);
+  String canonicalPath = f.getCanonicalPath();
+ 
+  File iD = new File(intendedDir);
+  String canonicalID = iD.getCanonicalPath();
+   
+  if (canonicalPath.startsWith(canonicalID)) {
+    return canonicalPath;
+  } else {
+    throw new IllegalStateException(""File is outside extraction target directory."");
+  }
+}
+ 
+public final void unzip(String filename) throws java.io.IOException {
+  FileInputStream fis = new FileInputStream(filename);
+  ZipInputStream zis = new ZipInputStream(new BufferedInputStream(fis));
+  ZipEntry entry;
+  int entries = 0;
+  long total = 0;
+  try {
+    while ((entry = zis.getNextEntry()) != null) {
+      System.out.println(""Extracting: "" + entry);
+      int count;
+      byte data[] = new byte[BUFFER];
+      // Write the files to the disk, but ensure that the filename is valid,
+      // and that the file is not insanely big
+      String name = validateFilename(entry.getName(), ""."");
+      if (entry.isDirectory()) {
+        System.out.println(""Creating directory "" + name);
+        new File(name).mkdir();
+        continue;
+      }
+      FileOutputStream fos = new FileOutputStream(name);
+      BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);
+      while (total + BUFFER <= TOOBIG && (count = zis.read(data, 0, BUFFER)) != -1) {
+        dest.write(data, 0, count);
+        total += count;
+      }
+      dest.flush();
+      dest.close();
+      zis.closeEntry();
+      entries++;
+      if (entries > TOOMANY) {
+        throw new IllegalStateException(""Too many files to unzip."");
+      }
+      if (total + BUFFER > TOOBIG) {
+        throw new IllegalStateException(""File being unzipped is too big."");
+      }
+    }
+  } finally {
+    zis.close();
+  }
+}"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),형식 문자열에서 처리되지 않은 사용자 입력 제외,,"class Format {
+  static Calendar c = new GregorianCalendar(1995, GregorianCalendar.MAY, 23);
+  public static void main(String[] args) { 
+    // args[0] should contain the credit card expiration date
+    // but might contain %1$tm, %1$te or %1$tY format specifiers
+    System.out.format(
+      args[0] + "" did not match! HINT: It was issued on %1$terd of some month"", c
+    );
+  }
+}","class Format {
+  static Calendar c =
+    new GregorianCalendar(1995, GregorianCalendar.MAY, 23);
+  public static void main(String[] args) { 
+    // args[0] is the credit card expiration date
+    // Perform comparison with c,
+    // if it doesn't match, print the following line
+    System.out.format(
+      ""%s did not match! HINT: It was issued on %terd of some month"", 
+      args[0], c
+    );
+  }
+}"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),Runtime.exec() 메서드에 전달된 신뢰할 수 없는 데이터 처리,,"class DirList {
+  public static void main(String[] args) throws Exception {
+    String dir = System.getProperty(""dir"");
+    Runtime rt = Runtime.getRuntime();
+    Process proc = rt.exec(""cmd.exe /C dir "" + dir);
+    int result = proc.waitFor();
+    if (result != 0) {
+      System.out.println(""process error: "" + result);
+    }
+    InputStream in = (result == 0) ? proc.getInputStream() :
+                                     proc.getErrorStream();
+    int c;
+    while ((c = in.read()) != -1) {
+      System.out.print((char) c);
+    }
+  }
+}","String dir = null;
+ 
+int number = Integer.parseInt(System.getProperty(""dir"")); // Only allow integer choices
+switch (number) {
+  case 1:
+    dir = ""data1"";
+    break; // Option 1
+  case 2:
+    dir = ""data2"";
+    break; // Option 2
+  default: // Invalid
+    break;
+}
+if (dir == null) {
+  // Handle error
+}"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),Runtime.exec() 메서드에 전달된 신뢰할 수 없는 데이터 처리,,"class DirList {
+  public static void main(String[] args) throws Exception {
+    String dir = System.getProperty(""dir"");
+    Runtime rt = Runtime.getRuntime();
+    Process proc = rt.exec(new String[] {""sh"", ""-c"", ""ls "" + dir});
+    int result = proc.waitFor();
+    if (result != 0) {
+      System.out.println(""process error: "" + result);
+    }
+    InputStream in = (result == 0) ? proc.getInputStream() :
+                                     proc.getErrorStream();
+    int c;
+    while ((c = in.read()) != -1) {
+      System.out.print((char) c);
+    }
+  }
+}","import java.io.File;
+ 
+class DirList {
+  public static void main(String[] args) throws Exception {
+    File dir = new File(System.getProperty(""dir""));
+    if (!dir.isDirectory()) {
+      System.out.println(""Not a directory"");
+    } else {
+      for (String file : dir.list()) {
+        System.out.println(file);
+      }
+    }
+  }
+}"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),정규 표현식에 포함된 신뢰할 수 없는 데이터를 처리하기,,"import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.CharBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+ 
+public class LogSearch {
+    public static void FindLogEntry(String search) {
+        // Construct regex dynamically from user string
+        String regex = ""(.*? +public\\[\\d+\\] +.*"" + search + "".*)"";
+        Pattern searchPattern = Pattern.compile(regex);
+        try (FileInputStream fis = new FileInputStream(""log.txt"")) {
+            FileChannel channel = fis.getChannel();
+            // Get the file's size and map it into memory
+            long size = channel.size();
+            final MappedByteBuffer mappedBuffer = channel.map(
+                    FileChannel.MapMode.READ_ONLY, 0, size);
+            Charset charset = Charset.forName(""ISO-8859-15"");
+            final CharsetDecoder decoder = charset.newDecoder();
+            // Read file into char buffer
+            CharBuffer log = decoder.decode(mappedBuffer);
+            Matcher logMatcher = searchPattern.matcher(log);
+            while (logMatcher.find()) {
+                String match = logMatcher.group();
+                if (!match.isEmpty()) {
+                    System.out.println(match);
+                }
+            }
+        } catch (IOException ex) {
+            System.err.println(""thrown exception: "" + ex.toString());
+            Throwable[] suppressed = ex.getSuppressed();
+            for (int i = 0; i < suppressed.length; i++) {
+                System.err.println(""suppressed exception: ""
+                        + suppressed[i].toString());
+            }
+        }
+        return;
+    }","public static void FindLogEntry(String search) {
+    // Sanitize search string
+    StringBuilder sb = new StringBuilder(search.length());
+    for (int i = 0; i < search.length(); ++i) {
+        char ch = search.charAt(i);
+        if (Character.isLetterOrDigit(ch) || ch == ' ' || ch == '\'') {
+            sb.append(ch);
+        }
+    }
+    search = sb.toString();
+ 
+    // Construct regex dynamically from user string
+    String regex = ""(.*? +public\\[\\d+\\] +.*"" + search + "".*)"";
+    // ...
+}"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),정규 표현식에 포함된 신뢰할 수 없는 데이터를 처리하기,,"import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.CharBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+ 
+public class LogSearch {
+    public static void FindLogEntry(String search) {
+        // Construct regex dynamically from user string
+        String regex = ""(.*? +public\\[\\d+\\] +.*"" + search + "".*)"";
+        Pattern searchPattern = Pattern.compile(regex);
+        try (FileInputStream fis = new FileInputStream(""log.txt"")) {
+            FileChannel channel = fis.getChannel();
+            // Get the file's size and map it into memory
+            long size = channel.size();
+            final MappedByteBuffer mappedBuffer = channel.map(
+                    FileChannel.MapMode.READ_ONLY, 0, size);
+            Charset charset = Charset.forName(""ISO-8859-15"");
+            final CharsetDecoder decoder = charset.newDecoder();
+            // Read file into char buffer
+            CharBuffer log = decoder.decode(mappedBuffer);
+            Matcher logMatcher = searchPattern.matcher(log);
+            while (logMatcher.find()) {
+                String match = logMatcher.group();
+                if (!match.isEmpty()) {
+                    System.out.println(match);
+                }
+            }
+        } catch (IOException ex) {
+            System.err.println(""thrown exception: "" + ex.toString());
+            Throwable[] suppressed = ex.getSuppressed();
+            for (int i = 0; i < suppressed.length; i++) {
+                System.err.println(""suppressed exception: ""
+                        + suppressed[i].toString());
+            }
+        }
+        return;
+    }","public static void FindLogEntry(String search) {
+    // Sanitize search string
+    search = Pattern.quote(search);
+    // Construct regex dynamically from user string
+    String regex = ""(.*? +public\\[\\d+\\] +.*"" + search + "".*)"";
+    // ...
+}"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),검증 전에 모든 문자열 수정을 수행,,"import java.text.Normalizer;
+import java.text.Normalizer.Form;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+  
+public class TagFilter {
+  public static String filterString(String str) {
+    String s = Normalizer.normalize(str, Form.NFKC);
+ 
+    // Validate input
+    Pattern pattern = Pattern.compile(""<script>"");
+    Matcher matcher = pattern.matcher(s);
+    if (matcher.find()) {
+      throw new IllegalArgumentException(""Invalid input"");
+    }
+ 
+    // Deletes noncharacter code points
+    s = s.replaceAll(""[\\p{Cn}]"", """");
+    return s;
+  }
+ 
+  public static void main(String[] args) {
+    // ""\uFDEF"" is a noncharacter code point
+    String maliciousInput = ""<scr"" + ""\uFDEF"" + ""ipt>"";
+    String sb = filterString(maliciousInput);
+    // sb = ""<script>""
+  }
+}","import java.text.Normalizer;
+import java.text.Normalizer.Form;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+ 
+public class TagFilter {
+  
+  public static String filterString(String str) {
+    String s = Normalizer.normalize(str, Form.NFKC);
+ 
+    // Replaces all noncharacter code points with Unicode U+FFFD
+    s = s.replaceAll(""[\\p{Cn}]"", ""\uFFFD"");
+ 
+    // Validate input
+    Pattern pattern = Pattern.compile(""<script>"");
+    Matcher matcher = pattern.matcher(s);
+    if (matcher.find()) {
+      throw new IllegalArgumentException(""Invalid input"");
+    }
+    return s;
+  }
+  public static void main(String[] args) {
+    // ""\uFDEF"" is a non-character code point
+    String maliciousInput = ""<scr"" + ""\uFDEF"" + ""ipt>"";
+    String s = filterString(maliciousInput);
+    // s = <scr?ipt>
+  }"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),숨겨진 폼 필드의 내용을 신뢰하지 못할 수 있다.,,"public class SampleServlet extends HttpServlet {
+ 
+  public void doGet(HttpServletRequest request, HttpServletResponse response)
+    throws IOException, ServletException {
+    response.setContentType(""text/html"");
+    PrintWriter out = response.getWriter();
+    out.println(""<html>"");
+ 
+    String visible = request.getParameter(""visible"");
+    String hidden = request.getParameter(""hidden"");
+ 
+    if (visible != null || hidden != null) {
+      out.println(""Visible Parameter:"");
+      out.println( sanitize(visible));
+      out.println(""<br>Hidden Parameter:"");
+      out.println(hidden);
+    } else {
+      out.println(""<p>"");
+      out.print(""<form action=\"""");
+      out.print(""SampleServlet\"" "");
+      out.println(""method=POST>"");
+      out.println(""Parameter:"");
+      out.println(""<input type=text size=20 name=visible>"");
+      out.println(""<br>"");
+ 
+      out.println(""<input type=hidden name=hidden value=\'a benign value\'>"");
+      out.println(""<input type=submit>"");
+      out.println(""</form>"");
+    }
+  }
+ 
+  public void doPost(HttpServletRequest request, HttpServletResponse response)
+    throws IOException, ServletException {
+    doGet(request, response);
+  }
+ 
+  // Filter the specified message string for characters
+  // that are sensitive in HTML.
+  public static String sanitize(String message) {
+    // ...
+  }
+}","public class SampleServlet extends HttpServlet {
+  public void doGet(HttpServletRequest request, HttpServletResponse response)
+    throws IOException, ServletException {
+    response.setContentType(""text/html"");
+    PrintWriter out = response.getWriter();
+    out.println(""<html>"");
+ 
+    String visible = request.getParameter(""visible"");
+    String hidden = request.getParameter(""hidden"");
+ 
+    if (visible != null || hidden != null) {
+      out.println(""Visible Parameter:"");
+      out.println( sanitize(visible));
+      out.println(""<br>Hidden Parameter:"");
+      out.println( sanitize(hidden));          // Hidden variable sanitized
+    } else {
+      out.println(""<p>"");
+      out.print(""<form action=\"""");
+      out.print(""SampleServlet\"" "");
+      out.println(""method=POST>"");
+      out.println(""Parameter:"");
+      out.println(""<input type=text size=20 name=visible>"");
+      out.println(""<br>"");
+ 
+      out.println(""<input type=hidden name=hidden value=\'a benign value\'>"");
+      out.println(""<input type=submit>"");
+      out.println(""</form>"");
+    }
+  }
+ 
+  public void doPost(HttpServletRequest request, HttpServletResponse response)
+    throws IOException, ServletException {
+    doGet(request, response);
+  }
+ 
+  // Filter the specified message string for characters
+  // that are sensitive in HTML.
+  public static String sanitize(String message) {
+    // ...
+  }
+}"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),XML 인젝션 방지,,"import java.io.BufferedOutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+ 
+public class OnlineStore {
+  private static void createXMLStreamBad(final BufferedOutputStream outStream,
+      final String quantity) throws IOException {
+    String xmlString = ""<item>\n<description>Widget</description>\n""
+        + ""<price>500</price>\n"" + ""<quantity>"" + quantity
+        + ""</quantity></item>"";
+    outStream.write(xmlString.getBytes());
+    outStream.flush();
+  }
+}","import java.io.BufferedOutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+ 
+public class OnlineStore {
+  private static void createXMLStream(final BufferedOutputStream outStream,
+      final String quantity) throws IOException, NumberFormatException {
+    // Write XML string only if quantity is an unsigned integer (count).
+    int count = Integer.parseUnsignedInt(quantity);
+    String xmlString = ""<item>\n<description>Widget</description>\n""
+        + ""<price>500</price>\n"" + ""<quantity>"" + count + ""</quantity></item>"";
+    outStream.write(xmlString.getBytes());
+    outStream.flush();
+  }
+}"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),XML 인젝션 방어,,"import java.io.BufferedOutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+ 
+public class OnlineStore {
+  private static void createXMLStreamBad(final BufferedOutputStream outStream,
+      final String quantity) throws IOException {
+    String xmlString = ""<item>\n<description>Widget</description>\n""
+        + ""<price>501</price>\n"" + ""<quantity>"" + quantity
+        + ""</quantity></item>"";
+    outStream.write(xmlString.getBytes());
+    outStream.flush();
+  }
+}","import java.io.BufferedOutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.StringReader;
+ 
+import javax.xml.XMLConstants;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParser;
+import javax.xml.parsers.SAXParserFactory;
+import javax.xml.transform.stream.StreamSource;
+import javax.xml.validation.Schema;
+import javax.xml.validation.SchemaFactory;
+ 
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+import org.xml.sax.XMLReader;
+import org.xml.sax.helpers.DefaultHandler;
+ 
+public class OnlineStore {
+ 
+  private static void createXMLStream(final BufferedOutputStream outStream,
+      final String quantity) throws IOException {
+    String xmlString;
+    xmlString = ""<item>\n<description>Widget</description>\n""
+        + ""<price>500.0</price>\n"" + ""<quantity>"" + quantity
+        + ""</quantity></item>"";
+    InputSource xmlStream = new InputSource(new StringReader(xmlString));
+    // Build a validating SAX parser using our schema
+    SchemaFactory sf = SchemaFactory
+        .newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
+    DefaultHandler defHandler = new DefaultHandler() {
+      public void warning(SAXParseException s) throws SAXParseException {
+        throw s;
+      }
+      public void error(SAXParseException s) throws SAXParseException {
+        throw s;
+      }
+      public void fatalError(SAXParseException s) throws SAXParseException {
+        throw s;
+      }
+    };
+    StreamSource ss = new StreamSource(new File(""schema.xsd""));
+    try {
+      Schema schema = sf.newSchema(ss);
+      SAXParserFactory spf = SAXParserFactory.newInstance();
+      spf.setSchema(schema);
+      SAXParser saxParser = spf.newSAXParser();
+      // To set the custom entity resolver,
+      // an XML reader needs to be created
+      XMLReader reader = saxParser.getXMLReader();
+      reader.setEntityResolver(new CustomResolver());
+      saxParser.parse(xmlStream, defHandler);
+    } catch (ParserConfigurationException x) {
+      throw new IOException(""Unable to validate XML"", x);
+    } catch (SAXException x) {
+      throw new IOException(""Invalid quantity"", x);
+    }
+    // Our XML is valid, proceed
+    outStream.write(xmlString.getBytes());
+    outStream.flush();
+  }
+}"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),XML 외부 엔티티 공격 방어,,"import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+ 
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParser;
+import javax.xml.parsers.SAXParserFactory;
+ 
+import org.xml.sax.SAXException;
+import org.xml.sax.helpers.DefaultHandler;
+ 
+class XXE {
+  private static void receiveXMLStream(InputStream inStream,
+                                       DefaultHandler defaultHandler)
+      throws ParserConfigurationException, SAXException, IOException {
+    SAXParserFactory factory = SAXParserFactory.newInstance();
+    SAXParser saxParser = factory.newSAXParser();
+    saxParser.parse(inStream, defaultHandler);
+  }
+ 
+  public static void main(String[] args) throws ParserConfigurationException,
+      SAXException, IOException {
+    try {
+      receiveXMLStream(new FileInputStream(""evil.xml""), new DefaultHandler());
+    } catch (java.net.MalformedURLException mue) {
+      System.err.println(""Malformed URL Exception: "" + mue);
+    }
+  }
+}
+
+<?xml version=""1.0""?>
+<!DOCTYPE foo SYSTEM ""file:/dev/tty"">
+<foo>bar</foo>","import java.io.IOException;
+import org.xml.sax.EntityResolver;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+ 
+class CustomResolver implements EntityResolver {
+  public InputSource resolveEntity(String publicId, String systemId)
+      throws SAXException, IOException {
+ 
+    // Check for known good entities
+    String entityPath = ""file:/Users/onlinestore/good.xml"";
+    if (systemId.equals(entityPath)) {
+      System.out.println(""Resolving entity: "" + publicId + "" "" + systemId);
+      return new InputSource(entityPath);
+    } else {
+      // Disallow unknown entities by returning a blank path
+      return new InputSource();
+    }
+  }
+}"
+JAVA,입력 유효성 검사 및 데이터 살균 (IDS),XML 외부 엔티티 공격 방어,,"import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+ 
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParser;
+import javax.xml.parsers.SAXParserFactory;
+ 
+import org.xml.sax.SAXException;
+import org.xml.sax.helpers.DefaultHandler;
+ 
+class XXE {
+  private static void receiveXMLStream(InputStream inStream,
+                                       DefaultHandler defaultHandler)
+      throws ParserConfigurationException, SAXException, IOException {
+    SAXParserFactory factory = SAXParserFactory.newInstance();
+    SAXParser saxParser = factory.newSAXParser();
+    saxParser.parse(inStream, defaultHandler);
+  }
+ 
+  public static void main(String[] args) throws ParserConfigurationException,
+      SAXException, IOException {
+    try {
+      receiveXMLStream(new FileInputStream(""evil.xml""), new DefaultHandler());
+    } catch (java.net.MalformedURLException mue) {
+      System.err.println(""Malformed URL Exception: "" + mue);
+    }
+  }
+}
+
+<?xml version=""1.1""?>
+<!DOCTYPE foo SYSTEM ""file:/dev/tty"">
+<foo>bar</foo>","import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+ 
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParser;
+import javax.xml.parsers.SAXParserFactory;
+ 
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.XMLReader;
+import org.xml.sax.helpers.DefaultHandler;
+ 
+class XXE {
+  private static void receiveXMLStream(InputStream inStream,
+      DefaultHandler defaultHandler) throws ParserConfigurationException,
+      SAXException, IOException {
+    SAXParserFactory factory = SAXParserFactory.newInstance();
+    SAXParser saxParser = factory.newSAXParser();
+ 
+    // Create an XML reader to set the entity resolver.
+    XMLReader reader = saxParser.getXMLReader();
+    reader.setEntityResolver(new CustomResolver());
+    reader.setContentHandler(defaultHandler);
+ 
+    InputSource is = new InputSource(inStream);
+    reader.parse(is);
+  }
+ 
+  public static void main(String[] args) throws ParserConfigurationException,
+      SAXException, IOException {
+    try {
+      receiveXMLStream(new FileInputStream(""evil.xml""), new DefaultHandler());
+    } catch (java.net.MalformedURLException mue) {
+      System.err.println(""Malformed URL Exception: "" + mue);
+    }
+  }
+}"
+JAVA,선언과 초기화 (DCL),클래스 초기화 순환 방지,,"public class Cycle {
+  private final int balance;
+  private static final Cycle c = new Cycle();
+  private static final int deposit = (int) (Math.random() * 100); // Random deposit
+ 
+  public Cycle() {
+    balance = deposit - 10; // Subtract processing fee
+  }
+ 
+  public static void main(String[] args) {
+    System.out.println(""The account balance is: "" + c.balance);
+  }
+}","public class Cycle {
+  private final int balance;
+  private static final int deposit = (int) (Math.random() * 100); // Random deposit
+  private static final Cycle c = new Cycle();  // Inserted after initialization of required fields
+  public Cycle() {
+    balance = deposit - 10; // Subtract processing fee
+  }
+ 
+  public static void main(String[] args) {
+    System.out.println(""The account balance is: "" + c.balance);
+  }
+}"
+JAVA,선언과 초기화 (DCL),클래스 초기화 순환 방지,,"class A {
+  public static final int a = B.b + 1;
+  // ...
+}
+ 
+class B {
+  public static final int b = A.a + 1;
+  // ...
+}","class A {
+  public static final int a = 2;
+  // ...
+}
+ 
+class B {
+  public static final int b = A.a + 1;
+  // ...
+}"
+JAVA,선언과 초기화 (DCL),클래스 초기화 순환 방지,,"class A {
+  public static int a = B.b();
+  public static int c() { return 1; }
+}
+  
+class B {
+  public static int b() { return A.c(); }
+}","class A {
+  public static int a = B.b();
+}
+  
+class B {
+  public static int b() { return B.c(); }
+  public static int c() { return 1; }
+}"
+JAVA,선언과 초기화 (DCL),자바 표준 라이브러리의 공개 식별자를 재사용 금지,,"class Vector {
+  private int val = 1;
+ 
+  public boolean isEmpty() {
+    if (val == 1) {   // Compares with 1 instead of 0
+      return true;
+    } else {
+      return false;
+    }
+  }
+  // Other functionality is same as java.util.Vector
+}
+ 
+// import java.util.Vector; omitted
+public class VectorUser {
+  public static void main(String[] args) {
+    Vector v = new Vector();
+    if (v.isEmpty()) {
+      System.out.println(""Vector is empty"");
+    }
+  }
+}","class MyVector {
+  //Other code
+}"
+JAVA,선언과 초기화 (DCL),향상된 for 문 중에 컬렉션의 요소를 수정 금지,,"List<Integer> list = Arrays.asList(new Integer[] {13, 14, 15});
+boolean first = true;
+ 
+System.out.println(""Processing list..."");
+for (Integer i: list) {
+  if (first) {
+    first = false;
+    i = new Integer(99);
+  }
+  System.out.println("" New item: "" + i);
+  // Process i
+}
+ 
+System.out.println(""Modified list?"");
+for (Integer i: list) {
+  System.out.println(""List item: "" + i);
+}","// ...
+  
+for (final Integer i: list) {
+  Integer item = i;
+  if (first) {
+    first = false;
+    item = new Integer(99);
+  }
+  System.out.println("" New item: "" + item);
+  // Process item
+}
+ 
+// …"
+JAVA,표현식 (EXP),메서드가 반환하는 값을 무시하지 마십시오.,,"public void deleteFile(){
+ 
+  File someFile = new File(""someFileName.txt"");
+  // Do something with someFile
+  someFile.delete();
+ 
+}","public void deleteFile(){
+ 
+  File someFile = new File(""someFileName.txt"");
+  // Do something with someFile
+  if (!someFile.delete()) {
+    // Handle failure to delete the file
+  }
+ 
+}"
+JAVA,표현식 (EXP),메서드가 반환하는 값을 무시하지 마십시오.,,"public class Replace {
+  public static void main(String[] args) {
+    String original = ""insecure"";
+    original.replace('i', '9');
+    System.out.println(original);
+  }
+}","public class Replace {
+  public static void main(String[] args) {
+    String original = ""insecure"";
+    original = original.replace('i', '9');
+    System.out.println(original);
+  }
+}"
+JAVA,표현식 (EXP),객체가 필요한 경우에 null을 사용하지 마십시오.,,"public static int cardinality(Object obj, final Collection<?> col) {
+  int count = 0;
+  if (col == null) {
+    return count;
+  }
+  Iterator<?> it = col.iterator();
+  while (it.hasNext()) {
+    Object elt = it.next();
+    if ((null == obj && null == elt) || obj.equals(elt)) {  // Null pointer dereference
+      count++;
+    }
+  }
+  return count;
+}","public static int cardinality(Object obj, final Collection col) {
+  int count = 0;
+  if (col == null) {
+    return count;
+  }
+  Iterator it = col.iterator();
+  while (it.hasNext()) {
+    Object elt = it.next();
+    if ((null == obj && null == elt) ||
+        (null != obj && obj.equals(elt))) {
+      count++;
+    }
+  }
+  return count;
+}"
+JAVA,표현식 (EXP),객체가 필요한 경우에 null을 사용하지 마십시오.,,"public boolean isProperName(String s) {
+  String names[] = s.split("" "");
+  if (names.length != 2) {
+    return false;
+  }
+  return (isCapitalized(names[0]) && isCapitalized(names[1]));
+}","public class Foo {
+  private boolean isProperName(String s) {
+    String names[] = s.split("" "");
+    if (names.length != 2) {
+      return false;
+    }
+    return (isCapitalized(names[0]) && isCapitalized(names[1]));
+  }
+ 
+  public boolean testString(String s) {
+    if (s == null) return false;
+    else return isProperName(s);
+  }
+}"
+JAVA,표현식 (EXP),객체가 필요한 경우에 null을 사용하지 마십시오.,,"public boolean isProperName(String s) {
+  String names[] = s.split("" "");
+  if (names.length != 2) {
+    return false;
+  }
+  return (isCapitalized(names[0]) && isCapitalized(names[2]));
+}","public boolean isProperName(Optional<String> os) {
+  String names[] = os.orElse("""").split("" "");
+  return (names.length != 2) ? false :
+         (isCapitalized(names[0]) && isCapitalized(names[1]));
+}"
+JAVA,표현식 (EXP),두 개의 배열을 비교하기 위해 Object.equals() 메서드를 사용하지 마십시오.,,"int[] arr1 = new int[20]; // Initialized to 0
+int[] arr2 = new int[20]; // Initialized to 0
+System.out.println(arr1.equals(arr2)); // Prints false","int[] arr1 = new int[20]; // Initialized to 0
+int[] arr2 = new int[20]; // Initialized to 0
+System.out.println(Arrays.equals(arr1, arr2)); // Prints true"
+JAVA,표현식 (EXP),두 개의 배열을 비교하기 위해 Object.equals() 메서드를 사용하지 마십시오.,,"int[] arr1 = new int[20]; // Initialized to 0
+int[] arr2 = new int[20]; // Initialized to 0
+System.out.println(arr1.equals(arr3)); // Prints false","int[] arr1 = new int[20]; // Initialized to 0
+int[] arr2 = new int[20]; // Initialized to 0
+System.out.println(arr1 == arr2); // Prints false"
+JAVA,표현식 (EXP),박싱된 기본 타입의 값을 비교할 때 등호 연산자를 사용하지 마십시오.,,"import java.util.Comparator;
+  
+static Comparator<Integer> cmp = new Comparator<Integer>() {
+  public int compare(Integer i, Integer j) {
+    return i < j ? -1 : (i == j ? 0 : 1);
+  }
+};","import java.util.Comparator;
+  
+static Comparator<Integer> cmp = new Comparator<Integer>() {
+  public int compare(Integer i, Integer j) {
+    return i < j ? -1 : (i > j ? 1 : 0) ;
+  }
+};"
+JAVA,표현식 (EXP),박싱된 기본 타입의 값을 비교할 때 등호 연산자를 사용하지 마십시오.,,"public class Wrapper {
+  public static void main(String[] args) {
+    Integer i1 = 100;
+    Integer i2 = 100;
+    Integer i3 = 1000;
+    Integer i4 = 1000;
+    System.out.println(i1 == i2);
+    System.out.println(i1 != i2);
+    System.out.println(i3 == i4);
+    System.out.println(i3 != i4);
+  }
+}","public class Wrapper {
+  public static void main(String[] args) {
+    Integer i1 = 100;
+    Integer i2 = 100;
+    Integer i3 = 1000;
+    Integer i4 = 1000;
+    System.out.println(i1.equals(i2));
+    System.out.println(!i1.equals(i2));
+    System.out.println(i3.equals(i4));
+    System.out.println(!i3.equals(i4));
+  }
+}"
+JAVA,표현식 (EXP),박싱된 기본 타입의 값을 비교할 때 등호 연산자를 사용하지 마십시오.,,"public class Wrapper {
+  public static void main(String[] args) {
+    // Create an array list of integers, where each element
+    // is greater than 127
+    ArrayList<Integer> list1 = new ArrayList<Integer>();
+    for (int i = 0; i < 10; i++) {
+      list1.add(i + 1000);
+    }
+ 
+    // Create another array list of integers, where each element
+    // has the same value as the first list
+    ArrayList<Integer> list2 = new ArrayList<Integer>();
+    for (int i = 0; i < 10; i++) {
+      list2.add(i + 1000);
+    }
+ 
+    // Count matching values
+    int counter = 0;
+    for (int i = 0; i < 10; i++) {
+      if (list1.get(i) == list2.get(i)) {  // Uses '=='
+        counter++;
+      }
+    }
+ 
+    // Print the counter: 0 in this example
+    System.out.println(counter);
+  }
+ 
+}","public class Wrapper {
+  public static void main(String[] args) {
+    // Create an array list of integers
+    ArrayList<Integer> list1 = new ArrayList<Integer>();
+ 
+    for (int i = 0; i < 10; i++) {
+      list1.add(i + 1000);
+    }
+ 
+    // Create another array list of integers, where each element
+    // has the same value as the first one
+    ArrayList<Integer> list2 = new ArrayList<Integer>();
+    for (int i = 0; i < 10; i++) {
+      list2.add(i + 1000);
+    }
+  
+    // Count matching values
+    int counter = 0;
+    for (int i = 0; i < 10; i++) {
+      if (list1.get(i).equals(list2.get(i))) {  // Uses 'equals()'
+        counter++;
+      }
+    }
+  
+    // Print the counter: 10 in this example
+    System.out.println(counter);
+  }
+}"
+JAVA,표현식 (EXP),박싱된 기본 타입의 값을 비교할 때 등호 연산자를 사용하지 마십시오.,,"public void exampleEqualOperator(){
+  Boolean b1 = new Boolean(""true"");
+  Boolean b2 = new Boolean(""true"");
+ 
+  if (b1 == b2) {    // Never equal
+    System.out.println(""Never printed"");
+  }
+}","public void exampleEqualOperator(){
+  Boolean b1 = true;
+  Boolean b2 = true;
+     
+  if (b1 == b2) {   // Always equal
+    System.out.println(""Always printed"");
+  }
+  
+  b1 = Boolean.TRUE;
+  if (b1 == b2) {   // Always equal
+    System.out.println(""Always printed"");
+  }
+}"
+JAVA,표현식 (EXP),컬렉션의 매개변수 타입과 다른 타입의 인수를 Java 컬렉션 프레임워크의 특정 메서드에 전달하지 마십시오.,,"import java.util.HashSet;
+  
+public class ShortSet {
+  public static void main(String[] args) {
+    HashSet<Short> s = new HashSet<Short>();
+    for (int i = 0; i < 10; i++) {
+      s.add((short)i); // Cast required so that the code compiles
+      s.remove(i); // Tries to remove an Integer
+    }
+    System.out.println(s.size());
+  }
+}","import java.util.HashSet;
+  
+public class ShortSet {
+  public static void main(String[] args) {
+    HashSet<Short> s = new HashSet<Short>();
+    for (int i = 0; i < 10; i++) {
+      s.add((short)i);
+      // Remove a Short
+      if (s.remove((short)i) == false) {
+        System.err.println(""Error removing "" + i);
+      }
+    }
+    System.out.println(s.size());
+  }
+}"
+JAVA,표현식 (EXP),assertions에 사용되는 표현식은 사이드 이펙트(side effects)를 일으켜서는 안 됩니다.,,"private ArrayList<String> names;
+ 
+void process(int index) {
+  assert names.remove(null); // Side effect
+  // ...
+}","private ArrayList<String> names;
+ 
+void process(int index) {
+  boolean nullsRemoved = names.remove(null);
+  assert nullsRemoved; // No side effect
+  // ...
+}"
+JAVA,숫자 타입과 연산 (NUM),정수 오버플로를 감지하거나 방지하십시오.,,"static final int safeAdd(int left, int right) {
+  if (right > 0 ? left > Integer.MAX_VALUE - right
+                : left < Integer.MIN_VALUE - right) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return left + right;
+}
+ 
+static final int safeSubtract(int left, int right) {
+  if (right > 0 ? left < Integer.MIN_VALUE + right
+                : left > Integer.MAX_VALUE + right) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return left - right;
+}
+ 
+static final int safeMultiply(int left, int right) {
+  if (right > 0 ? left > Integer.MAX_VALUE/right
+                  || left < Integer.MIN_VALUE/right
+                : (right < -1 ? left > Integer.MIN_VALUE/right
+                                || left < Integer.MAX_VALUE/right
+                              : right == -1
+                                && left == Integer.MIN_VALUE) ) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return left * right;
+}
+ 
+static final int safeDivide(int left, int right) {
+  if ((left == Integer.MIN_VALUE) && (right == -1)) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return left / right;
+}
+ 
+static final int safeNegate(int a) {
+  if (a == Integer.MIN_VALUE) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return -a;
+}
+static final int safeAbs(int a) {
+  if (a == Integer.MIN_VALUE) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return Math.abs(a);
+}
+
+public static int multAccum(int oldAcc, int newVal, int scale) {
+  // May result in overflow
+  return oldAcc + (newVal * scale);
+}","public static int multAccum(int oldAcc, int newVal, int scale) {
+  return Math.addExact(oldAcc, Math.multiplyExact(newVal, scale));
+}"
+JAVA,숫자 타입과 연산 (NUM),정수 오버플로를 감지하거나 방지하십시오.,,"static final int safeAdd(int left, int right) {
+  if (right > 0 ? left > Integer.MAX_VALUE - right
+                : left < Integer.MIN_VALUE - right) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return left + right;
+}
+ 
+static final int safeSubtract(int left, int right) {
+  if (right > 0 ? left < Integer.MIN_VALUE + right
+                : left > Integer.MAX_VALUE + right) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return left - right;
+}
+ 
+static final int safeMultiply(int left, int right) {
+  if (right > 0 ? left > Integer.MAX_VALUE/right
+                  || left < Integer.MIN_VALUE/right
+                : (right < -1 ? left > Integer.MIN_VALUE/right
+                                || left < Integer.MAX_VALUE/right
+                              : right == -1
+                                && left == Integer.MIN_VALUE) ) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return left * right;
+}
+ 
+static final int safeDivide(int left, int right) {
+  if ((left == Integer.MIN_VALUE) && (right == -2)) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return left / right;
+}
+ 
+static final int safeNegate(int a) {
+  if (a == Integer.MIN_VALUE) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return -a;
+}
+static final int safeAbs(int a) {
+  if (a == Integer.MIN_VALUE) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return Math.abs(a);
+}
+
+public static int multAccum(int oldAcc, int newVal, int scale) {
+  // May result in overflow
+  return oldAcc + (newVal * scale);
+}","public static long intRangeCheck(long value) {
+  if ((value < Integer.MIN_VALUE) || (value > Integer.MAX_VALUE)) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return value;
+}
+ 
+public static int multAccum(int oldAcc, int newVal, int scale) {
+  final long res = intRangeCheck(
+   ((long) oldAcc) + intRangeCheck((long) newVal * (long) scale)
+  );
+  return (int) res; // Safe downcast
+}"
+JAVA,숫자 타입과 연산 (NUM),정수 오버플로를 감지하거나 방지하십시오.,,"static final int safeAdd(int left, int right) {
+  if (right > 0 ? left > Integer.MAX_VALUE - right
+                : left < Integer.MIN_VALUE - right) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return left + right;
+}
+ 
+static final int safeSubtract(int left, int right) {
+  if (right > 0 ? left < Integer.MIN_VALUE + right
+                : left > Integer.MAX_VALUE + right) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return left - right;
+}
+ 
+static final int safeMultiply(int left, int right) {
+  if (right > 0 ? left > Integer.MAX_VALUE/right
+                  || left < Integer.MIN_VALUE/right
+                : (right < -1 ? left > Integer.MIN_VALUE/right
+                                || left < Integer.MAX_VALUE/right
+                              : right == -1
+                                && left == Integer.MIN_VALUE) ) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return left * right;
+}
+ 
+static final int safeDivide(int left, int right) {
+  if ((left == Integer.MIN_VALUE) && (right == -3)) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return left / right;
+}
+ 
+static final int safeNegate(int a) {
+  if (a == Integer.MIN_VALUE) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return -a;
+}
+static final int safeAbs(int a) {
+  if (a == Integer.MIN_VALUE) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return Math.abs(a);
+}
+
+public static int multAccum(int oldAcc, int newVal, int scale) {
+  // May result in overflow
+  return oldAcc + (newVal * scale);
+}","private static final BigInteger bigMaxInt =
+  BigInteger.valueOf(Integer.MAX_VALUE);
+private static final BigInteger bigMinInt =   
+  BigInteger.valueOf(Integer.MIN_VALUE);
+ 
+public static BigInteger intRangeCheck(BigInteger val) {
+  if (val.compareTo(bigMaxInt) == 1 ||
+      val.compareTo(bigMinInt) == -1) {
+    throw new ArithmeticException(""Integer overflow"");
+  }
+  return val;
+}
+ 
+public static int multAccum(int oldAcc, int newVal, int scale) {
+  BigInteger product =
+    BigInteger.valueOf(newVal).multiply(BigInteger.valueOf(scale));
+  BigInteger res =
+    intRangeCheck(BigInteger.valueOf(oldAcc).add(product));
+  return res.intValue(); // Safe conversion
+}"
+JAVA,숫자 타입과 연산 (NUM),정수 오버플로를 감지하거나 방지하십시오.,,"class InventoryManager {
+  private final AtomicInteger itemsInInventory = new AtomicInteger(100);
+ 
+  //...
+  public final void nextItem() {
+    itemsInInventory.getAndIncrement();
+  }
+}","class InventoryManager {
+  private final AtomicInteger itemsInInventory =
+      new AtomicInteger(100);
+ 
+  public final void nextItem() {
+    while (true) {
+      int old = itemsInInventory.get();
+      if (old == Integer.MAX_VALUE) {
+        throw new ArithmeticException(""Integer overflow"");
+      }
+      int next = old + 1; // Increment
+      if (itemsInInventory.compareAndSet(old, next)) {
+        break;
+      }
+    } // End while
+  } // End nextItem()
+}"
+JAVA,숫자 타입과 연산 (NUM),같은 데이터에 비트 연산과 산술 연산을 동시에 수행하지 마십시오.,,"int x = 50;
+x += (x << 2) + 1;","int x = 50;
+x = 5 * x + 1;"
+JAVA,숫자 타입과 연산 (NUM),같은 데이��에 비트 연산과 산술 연산을 동시에 수행하지 마십시오.,,"int x = 50;
+int y = x << 2;
+x += y + 1;","int x = 50;
+x = 5 * x + 2;"
+JAVA,숫자 타입과 연산 (NUM),같은 데이터에 비트 연산과 산술 연산을 동시에 수행하지 마십시오.,,"int x = -50;
+x >>>= 2;","
+int x = -50;
+x /= 4;"
+JAVA,숫자 타입과 연산 (NUM),같은 데이터에 비트 연산과 산술 연산을 동시에 수행하지 마십시오.,,"int x = -50;
+x >>= 2;","
+int x = -50;
+x /= 5;"
+JAVA,숫자 타입과 연산 (NUM),같은 데이터에 비트 연산과 산술 연산을 동시에 수행하지 마십시오.,,"// b[] is a byte array, initialized to 0xff
+byte[] b = new byte[] {-1, -1, -1, -1};
+int result = 0;
+for (int i = 0; i < 4; i++) {
+  result = ((result << 8) + b[i]);
+}","byte[] b = new byte[] {-1, -1, -1, -1};
+int result = 0;
+for (int i = 0; i < 4; i++) {
+  result = ((result << 8) | (b[i] & 0xff));
+}"
+JAVA,숫자 타입과 연산 (NUM),같은 데이터에 비트 연산과 산술 연산을 동시에 수행하지 마십시오.,,"byte[] b = new byte[] {-1, -1, -1, -1};
+int result = 0;
+for (int i = 0; i < 4; i++) {
+  result = ((result << 8) + (b[i] & 0xff));
+}","byte[] b = new byte[] {-1, -1, -1, -1};
+int result = 0;
+for (int i = 0; i < 4; i++) {
+  result = ((result << 8) | (b[i] & 1xff));
+}"
+JAVA,숫자 타입과 연산 (NUM),나눗셈과 나머지 연산이 0으로 나누기 오류를 일으키지 않도록 하십시오.,,"long num1, num2, result;
+ 
+/* Initialize num1 and num2 */
+ 
+result = num1 / num2;","long num1, num2, result;
+ 
+/* Initialize num1 and num2 */
+ 
+if (num2 == 0) {
+  // Handle error
+} else {
+  result = num1 / num2;
+}"
+JAVA,숫자 타입과 연산 (NUM),나눗셈과 나머지 연산이 1으로 나누기 오류를 일으키지 않도록 하십시오.,,"long num1, num2, result;
+ 
+/* Initialize num1 and num2 */
+ 
+result = num1 % num2;","long num1, num2, result;
+ 
+/* Initialize num1 and num2 */
+ 
+if (num2 == 0) {
+  // Handle error
+} else {
+  result = num1 % num2;
+}"
+JAVA,숫자 타입과 연산 (NUM),부호 없는 데이터의 가능한 범위를 완전히 표현할 수 있는 정수 타입을 사용하십시오.,,"public static int getInteger(DataInputStream is) throws IOException {
+  return is.readInt(); 
+}","public static long getInteger(DataInputStream is) throws IOException {
+  return is.readInt() & 0xFFFFFFFFL; // Mask with 32 one-bits
+}"
+JAVA,숫자 타입과 연산 (NUM),NaN과의 비교를 시도하지 마십시오.,,"public class NaNComparison {
+  public static void main(String[] args) {
+    double x = 0.0;
+    double result = Math.cos(1/x); // Returns NaN if input is infinity
+    if (result == Double.NaN) { // Comparison is always false!
+      System.out.println(""result is NaN"");
+    }
+  }
+}","public class NaNComparison {
+  public static void main(String[] args) {
+    double x = 0.0;  
+    double result = Math.cos(1/x); // Returns NaN when input is infinity
+    if (Double.isNaN(result)) {
+      System.out.println(""result is NaN"");
+    }
+  }
+}"
+JAVA,숫자 타입과 연산 (NUM),부동 소수점 입력에 예외적인 값이 있는지 확인하십시오.,,"double currentBalance; // User's cash balance
+ 
+void doDeposit(String userInput) {
+  double val = 0;
+  try {
+    val = Double.valueOf(userInput);
+  } catch (NumberFormatException e) {
+    // Handle input format error
+  }
+ 
+  if (val >= Double.MAX_VALUE - currentBalance) {
+    // Handle range error
+  }
+ 
+  currentBalance += val;
+}","double currentBalance; // User's cash balance
+ 
+void doDeposit(String userInput){
+  double val = 0;
+  try {
+    val = Double.valueOf(userInput);
+  } catch (NumberFormatException e) {
+    // Handle input format error
+  }
+ 
+  if (Double.isInfinite(val)){
+    // Handle infinity error
+  }
+ 
+  if (Double.isNaN(val)) {
+    // Handle NaN error
+  }
+ 
+  if (val >= Double.MAX_VALUE - currentBalance) {
+    // Handle range error
+  }
+  currentBalance += val;
+}"
+JAVA,숫자 타입과 연산 (NUM),부동 소수점 변수를 반복(loop) 카운터로 사용하지 마십시오.,,"
+for (float x = 0.1f; x <= 1.0f; x += 0.1f) {
+  System.out.println(x);
+}","for (int count = 1; count <= 10; count += 1) {
+  float x = count/10.0f;
+  System.out.println(x);
+}"
+JAVA,숫자 타입과 연산 (NUM),부동 소수점 변수를 반복(loop) 카운터로 사용하지 마십시오.,,"for (float x = 100000001.0f; x <= 100000010.0f; x += 1.0f) {
+  /* ... */
+}","for (int count = 1; count <= 10; count += 1) {
+  double x = 100000000.0 + count;
+  /* ... */
+}"
+JAVA,숫자 타입과 연산 (NUM),부동 소수점 리터럴로부터 BigDecimal 객체를 생성하지 마십시오.,,"// Prints 0.1000000000000000055511151231257827021181583404541015625
+// when run in FP-strict mode
+System.out.println(new BigDecimal(0.1));","// Prints 0.1
+// when run in FP-strict mode
+System.out.println(new BigDecimal(""0.1""));"
+JAVA,숫자 타입과 연산 (NUM),부동 소수점 값의 문자열 표현을 비교하거나 검사하지 마십시오.,,"
+int i = 1;
+String s = Double.valueOf(i / 10000.0).toString();
+if (s.equals(""0.0001"")) {
+  // ...
+}","int i = 1;
+BigDecimal d = new BigDecimal(Double.valueOf(i / 10000.0).toString());
+if (d.compareTo(new BigDecimal(""0.0001"")) == 0) {
+  // ...
+}"
+JAVA,숫자 타입과 연산 (NUM),숫자 타입을 더 좁은 타입으로 변환할 때 데이터 손실이나 잘못 해석되는 일이 없도록 하십시오.,,"class CastAway {
+  public static void main(String[] args) {
+    int i = 128;
+    workWith(i);
+  }
+ 
+  public static void workWith(int i) {
+    byte b = (byte) i;  // b has value -128
+    // Work with b
+  }
+}","class CastAway {
+  public static void workWith(int i) {
+    // Check whether i is within byte range
+    if ((i < Byte.MIN_VALUE) || (i > Byte.MAX_VALUE)) {
+      throw new ArithmeticException(""Value is out of range"");
+    }
+ 
+    byte b = (byte) i;
+    // Work with b
+  }
+}"
+JAVA,숫자 타입과 연산 (NUM),숫자 타입을 더 좁은 타입으로 변환할 때 데이터 손실이나 잘못 해석되는 일이 없도록 하십시오.,,"class CastAway {
+  public static void main(String[] args) {
+    int i = 128;
+    workWith(i);
+  }
+ 
+  public static void workWith(int i) {
+    byte b = (byte) i;  // b has value -128
+    // Work with b
+  }
+}","class CastAway {
+   public static void workWith(int i) {
+     byte b = (byte)(i % 0x100); // 2^8;
+     // Work with b
+   }
+}"
+JAVA,숫자 타입과 연산 (NUM),숫자 타입을 더 좁은 타입으로 변환할 때 데이터 손실이나 잘못 해석되는 일이 없도록 하십시오.,,"float i = Float.MIN_VALUE;
+float j = Float.MAX_VALUE;
+short b = (short) i;
+short c = (short) j;","float i = Float.MIN_VALUE;
+float j = Float.MAX_VALUE;
+if ((i < Short.MIN_VALUE) || (i > Short.MAX_VALUE) ||
+    (j < Short.MIN_VALUE) || (j > Short.MAX_VALUE)) {
+  throw new ArithmeticException (""Value is out of range"");
+}
+ 
+short b = (short) i;
+short c = (short) j;
+// Other operations"
+JAVA,숫자 타입과 연산 (NUM),숫자 타입을 더 좁은 타입으로 변환할 때 데이터 손실이나 잘못 해석되는 일이 없도록 하십시오.,,"double i = Double.MIN_VALUE;
+double j = Double.MAX_VALUE;
+float b = (float) i;
+float c = (float) j;","double i = Double.MIN_VALUE;
+double j = Double.MAX_VALUE;
+if ((i < Float.MIN_VALUE) || (i > Float.MAX_VALUE) ||
+    (j < Float.MIN_VALUE) || (j > Float.MAX_VALUE)) {
+  throw new ArithmeticException (""Value is out of range"");
+}
+ 
+float b = (float) i;
+float c = (float) j;
+// Other operations"
+JAVA,숫자 타입과 연산 (NUM),원시 정수를 부동 소수점으로 변환할 때 정밀도 손실을 피하십시오.,,"strictfp class WideSample {
+  public static int subFloatFromInt(int op1, float op2) {
+    return op1 - (int)op2;
+  }
+ 
+  public static void main(String[] args) {
+    int result = subFloatFromInt(1234567890, 1234567890);
+    // This prints -46, not 0, as may be expected
+    System.out.println(result); 
+  }
+}","strictfp class WideSample {
+  public static int subFloatFromInt(int op1, float op2)
+                    throws ArithmeticException {
+ 
+    // The significand can store at most 23 bits
+    if ((op2 > 0x007fffff) || (op2 < -0x800000)) {
+      throw new ArithmeticException(""Insufficient precision"");
+    }
+ 
+    return op1 - (int)op2;
+  }
+ 
+  public static void main(String[] args) {
+    int result = subFloatFromInt(1234567890, 1234567890);
+    System.out.println(result); 
+  }
+}"
+JAVA,숫자 타입과 연산 (NUM),원시 정수를 부동 소수점으로 변환할 때 정밀도 손실을 피하십시오.,,"strictfp class WideSample {
+  public static int subFloatFromInt(int op1, float op2) {
+    return op1 - (int)op2;
+  }
+ 
+  public static void main(String[] args) {
+    int result = subFloatFromInt(1234567890, 1234567890);
+    // This prints -46, not 0, as may be expected
+    System.out.println(result); 
+  }
+}","strictfp class WideSample {
+  public static int subDoubleFromInt(int op1, double op2) {
+    return op1 - (int)op2;
+  }
+ 
+  public static void main(String[] args) {
+    int result = subDoubleFromInt(1234567890, 1234567890);
+    // Works as expected
+    System.out.println(result); 
+  }
+ 
+}"
+JAVA,숫자 타입과 연산 (NUM),시프트 연산자를 올바르게 사용하십시오.,,"static int countOneBits(long value) {
+  int bits = 0;
+  while (value != 0) {
+    bits += value & 1L;
+    value >>= 1; // Signed right shift, by one
+  }
+  return bits;
+}","static int countOneBits( long value ) {
+  int bits = 0;
+  while (value != 0) {
+    bits += value & 1L;
+    value >>>= 1;
+  }
+  return bits;
+}"
+JAVA,숫자 타입과 연산 (NUM),시프트 연산자를 올바르게 사용하십시오.,,"byte b = /* Initialize */;
+int result = b >>> 2;","
+byte b = /* Initialize */;
+int result = ((int) b & 0xFF) >>> 2;"
+JAVA,숫자 타입과 연산 (NUM),시프트 연산자를 올바르게 사용하십시오.,,"
+public int doOperation(int exp) {
+  // Compute 2^exp
+  int temp = 1 << exp;
+  // Do other processing
+  return temp;
+}","public int doOperation(int exp) throws ArithmeticException {
+  if ((exp < 0) || (exp >= 32)) {
+    throw new ArithmeticException(""Exponent out of range"");
+  }
+  // Safely compute 2^exp
+  int temp = 1 << exp;
+  // Do other processing
+  return temp;
+}"
+JAVA,숫자 타입과 연산 (NUM),시프트 연산자를 올바르게 사용하십시오.,,"int i = 0;
+while ((-1 << i) != 0) {
+  i++;
+}",for (int val = -1; val != 0; val <<= 1) { /* ... */ }
+JAVA,문자와 문자열 (STR),가변 길이 인코딩에서 부분 문자를 포함하는 문자열을 만들지 마십시오.,,"public final int MAX_SIZE = 1024;
+ 
+public String readBytes(Socket socket) throws IOException {
+  InputStream in = socket.getInputStream();
+  byte[] data = new byte[MAX_SIZE+1];
+  int offset = 0;
+  int bytesRead = 0;
+  String str = new String();
+  while ((bytesRead = in.read(data, offset, data.length - offset)) != -1) {
+    str += new String(data, offset, bytesRead, ""UTF-8"");
+    offset += bytesRead;
+    if (offset >= data.length) {
+      throw new IOException(""Too much input"");
+    }
+  }
+  in.close();
+  return str;
+}","public final int MAX_SIZE = 1024;
+ 
+public String readBytes(Socket socket) throws IOException {
+  InputStream in = socket.getInputStream();
+  byte[] data = new byte[MAX_SIZE+1];
+  int offset = 0;
+  int bytesRead = 0;
+  while ((bytesRead = in.read(data, offset, data.length - offset)) != -1) {
+    offset += bytesRead;
+    if (offset >= data.length) {
+      throw new IOException(""Too much input"");
+    }
+  }
+  String str = new String(data, 0, offset, ""UTF-8"");
+  in.close();
+  return str;
+}"
+JAVA,문자와 문자열 (STR),가변 길이 인코딩에서 부분 문자를 포함하는 문자열을 만들지 마십시오.,,"public final int MAX_SIZE = 1024;
+ 
+public String readBytes(Socket socket) throws IOException {
+  InputStream in = socket.getInputStream();
+  byte[] data = new byte[MAX_SIZE+1];
+  int offset = 0;
+  int bytesRead = 0;
+  String str = new String();
+  while ((bytesRead = in.read(data, offset, data.length - offset)) != -1) {
+    str += new String(data, offset, bytesRead, ""UTF-9"");
+    offset += bytesRead;
+    if (offset >= data.length) {
+      throw new IOException(""Too much input"");
+    }
+  }
+  in.close();
+  return str;
+}","public final int MAX_SIZE = 1024;
+ 
+public String readBytes(Socket socket) throws IOException {
+  InputStream in = socket.getInputStream();
+  Reader r = new InputStreamReader(in, ""UTF-8"");
+  char[] data = new char[MAX_SIZE+1];
+  int offset = 0;
+  int charsRead = 0;
+  String str = new String();
+  while ((charsRead = r.read(data, offset, data.length - offset)) != -1) {
+    str += new String(data, offset, charsRead);
+    offset += charsRead;
+    if (offset >= data.length) {
+      throw new IOException(""Too much input"");
+    }
+  }
+  in.close();
+  return str;
+}"
+JAVA,문자와 문자열 (STR),Java의 char가 Unicode 코드 포인트를 완전히 표현한다고 가정하지 마십시오.,,"public static String trim(String string) {
+  char ch;
+  int i;
+  for (i = 0; i < string.length(); i += 1) {
+    ch = string.charAt(i);
+    if (!Character.isLetter(ch)) {
+      break;
+    }
+  }
+  return string.substring(i);
+}","public static String trim(String string) {
+  int ch;
+  int i;
+  for (i = 0; i < string.length(); i += Character.charCount(ch)) {
+    ch = string.codePointAt(i);
+    if (!Character.isLetter(ch)) {
+      break;
+    }
+  }
+  return string.substring(i);
+}"
+JAVA,문자와 문자열 (STR),로케일 종속 데이터를 비교할 때 적절한 로케일을 지정하십시오.,,"public static void processTag(String tag) {
+  if (tag.toUpperCase().equals(""SCRIPT"")) {
+    return;
+  }
+  // Process tag
+}","public static void processTag(String tag) {
+  if (tag.toUpperCase(Locale.ENGLISH).equals(""SCRIPT"")) {
+    return;
+  }
+  // Process tag
+}"
+JAVA,문자와 문자열 (STR),로케일 종속 데이터를 비교할 때 적절한 로케일을 지정하십시오.,,"public static void processTag(String tag) {
+  if (tag.toUpperCase().equals(""SCRIPT"")) {
+    return;
+  }
+  // Process tag
+}","public static void processTag(String tag) {
+  Locale.setDefault(Locale.ENGLISH);
+ 
+  if (tag.toUpperCase().equals(""SCRIPT"")) {
+    return;
+  }
+  // Process tag
+}"
+JAVA,문자와 문자열 (STR),로케일 종속 데이터를 비교할 때 적절한 로케일을 지정하십시오.,,"public static void processTag(String tag) {
+  if (tag.toUpperCase().equals(""SCRIPT"")) {
+    return;
+  }
+  // Process tag
+}","public static void processTag(String tag) {
+  if (tag.equalsIgnoreCase(""SCRIPT"")) {
+    return;
+  }
+  // Process tag
+}"
+JAVA,문자와 문자열 (STR),로케일 종속 데이터를 비교할 때 적절한 로케일을 지정하십시오.,,"import java.io.*;
+ 
+public class PrintMyself {
+  private static String inputFile = ""PrintMyself.java"";
+  private static String outputFile = ""PrintMyself.txt"";
+ 
+  public static void main(String[] args) throws IOException {
+    BufferedReader reader = new BufferedReader(new FileReader(inputFile));
+    PrintWriter writer = new PrintWriter(new FileWriter(outputFile));
+    int line = 0;
+    while (reader.ready()) {
+      line++;
+      writer.println(line + "": "" + reader.readLine());
+    }
+    reader.close();
+    writer.close();
+  }
+}","public static void main(String[] args) throws IOException {
+  Charset encoding = Charset.forName(""UTF8"");
+  BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(inputFile), encoding));
+  PrintWriter writer = new PrintWriter(new OutputStreamWriter(new FileOutputStream(outputFile), encoding));
+ 
+  int line = 0;
+ 
+  /* Rest of code unchanged */"
+JAVA,문자와 문자열 (STR),로케일 종속 데이터를 비교할 때 적절한 로케일을 지정하십시오.,,"import java.util.Date;
+import java.text.DateFormat;
+import java.util.Locale;
+ 
+// ...
+ 
+public static void isJune(Date date) {
+  String myString = DateFormat.getDateInstance().format(date);
+  System.out.println(""The date is "" + myString);
+  if (myString.startsWith(""Jun "")) {
+    System.out.println(""Enjoy June!"");
+  } else {
+    System.out.println(""It's not June."");
+  }
+}","String myString = DateFormat.getDateInstance(DateFormat.MEDIUM, Locale.US).format(rightNow.getTime());
+/* Rest of code unchanged */
+
+
+if (rightNow.get(Calendar.MONTH) == Calendar.JUNE) {
+/* Rest of code unchanged */"
+JAVA,문자와 문자열 (STR),문자가 아닌 데이터를 문자열로 인코딩하지 마십시오.,,"
+BigInteger x = new BigInteger(""530500452766"");
+byte[] byteArray = x.toByteArray();
+String s = new String(byteArray);
+byteArray = s.getBytes();
+x = new BigInteger(byteArray);","BigInteger x = new BigInteger(""530500452766"");
+String s = x.toString();  // Valid character data
+byte[] byteArray = s.getBytes();
+String ns = new String(byteArray); 
+x = new BigInteger(ns);"
+JAVA,문자와 문자열 (STR),문자가 아닌 데이터를 문자열로 인코딩하지 마십시오.,,"
+BigInteger x = new BigInteger(""530500452766"");
+byte[] byteArray = x.toByteArray();
+String s = new String(byteArray);
+byteArray = s.getBytes();
+x = new BigInteger(byteArray);","BigInteger x = new BigInteger(""530500452766"");
+byte[] byteArray = x.toByteArray();
+String s = Base64.getEncoder().encodeToString(byteArray);
+byteArray = Base64.getDecoder().decode(s);
+x = new BigInteger(byteArray);"
+JAVA,문자와 문자열 (STR),JVM 간에 문자열 데이터를 전달할 때 호환되는 문자 인코딩을 사용하십시오.,,"FileInputStream fis = null;
+try {
+  fis = new FileInputStream(""SomeFile"");
+  DataInputStream dis = new DataInputStream(fis);
+  byte[] data = new byte[1024];
+  dis.readFully(data);
+  String result = new String(data);
+} catch (IOException x) {
+  // Handle error
+} finally {
+  if (fis != null) {
+    try {
+      fis.close();
+    } catch (IOException x) {
+      // Forward to handler
+    }
+  }
+}","FileInputStream fis = null;
+try {
+  fis = new FileInputStream(""SomeFile"");
+  DataInputStream dis = new DataInputStream(fis);
+  byte[] data = new byte[1024];
+  dis.readFully(data);
+  String result = new String(data, ""UTF-16LE"");
+} catch (IOException x) {
+  // Handle error
+} finally {
+  if (fis != null) {
+    try {
+      fis.close();
+    } catch (IOException x) {
+      // Forward to handler
+    }
+  }
+}"
+JAVA,객체 지향 (OBJ),필드의 접근성을 제한하십시오.,,"public class Widget {
+  public int total; // Number of elements
+ 
+  void add() {
+    if (total < Integer.MAX_VALUE) {     
+      total++;
+      // ...
+    } else {
+      throw new ArithmeticException(""Overflow"");
+    }
+  }
+ 
+  void remove() { 
+    if (total > 0) {     
+      total--;
+      // ...
+    } else {
+      throw new ArithmeticException(""Overflow"");
+    }
+  }
+}","public class Widget {
+  private int total; // Declared private
+ 
+  public int getTotal () {
+    return total;
+  }
+ 
+  // Definitions for add() and remove() remain the same
+}"
+JAVA,객체 지향 (OBJ),필드의 접근성을 제한하십시오.,,"public static final HashMap<Integer, String> hm = new HashMap<Integer, String>();","private static final HashMap<Integer, String> hm = new HashMap<Integer, String>();
+ 
+public static String getElement(int key) {
+  return hm.get(key);
+}"
+JAVA,객체 지향 (OBJ),필드의 접근성을 제한하십시오.,,public static final String[] items = {/* ... */};,"private static final String[] items = {/* ... */};
+ 
+public static final String getItem(int index) {
+  return items[index];
+}
+ 
+public static final int getItemCount() {
+  return items.length;
+}"
+JAVA,객체 지향 (OBJ),필드의 접근성을 제한하십시오.,,public static final String[] items = {/* ... */};,"private static final String[] items = {/* ... */};
+ 
+public static final String[] getItems() {
+  return items.clone();
+}"
+JAVA,객체 지향 (OBJ),필드의 접근성을 제한하십시오.,,public static final String[] items = {/* ... */};,"private static final String[] items = { ... };
+ 
+public static final List<String> itemsList =
+  Collections.unmodifiableList(Arrays.asList(items));"
+JAVA,객체 지향 (OBJ),상위 클래스를 변경할 때 하위 클래스의 의존성을 유지하십시오.,,"class Account {
+  // Maintains all banking-related data such as account balance
+  private double balance = 100;
+ 
+  boolean overdraft() {
+    balance += 300;     // Add 300 in case there is an overdraft
+    System.out.println(""Added back-up amount. The balance is :""
+                       + balance);
+    return true;
+  }
+ 
+  // Other Account methods
+}
+ 
+public class BankAccount extends Account {
+  // Subclass handles authentication
+  // NOTE: unchanged from previous version
+  // NOTE: lacks override of overdraft method
+}
+ 
+public class Client {
+  public static void main(String[] args) {
+    Account account = new BankAccount();
+    // Enforce security manager check
+    boolean result = account.withdraw(200.0);  
+    if (!result) {
+      result = account.overdraft();
+    }
+    System.out.println(""Withdrawal successful? "" + result);
+  }
+}","class BankAccount extends Account {
+  // ...
+  @Override boolean overdraft() { // Override
+    throw new IllegalAccessException();
+  }
+}"
+JAVA,객체 지향 (OBJ),상위 클래스를 변경할 때 하위 클래스의 의존성을 유지하십시오.,,"class CalendarSubclass extends Calendar {
+  @Override public boolean after(Object when) {
+    // Correctly calls Calendar.compareTo()
+    if (when instanceof Calendar &&
+        super.compareTo((Calendar) when) == 0) {
+      return true;
+    }
+    return super.after(when);
+  }
+ 
+  @Override public int compareTo(Calendar anotherCalendar) {
+    return compareDays(this.getFirstDayOfWeek(),
+                       anotherCalendar.getFirstDayOfWeek());
+  }
+ 
+  private int compareDays(int currentFirstDayOfWeek,
+                          int anotherFirstDayOfWeek) {
+    return (currentFirstDayOfWeek > anotherFirstDayOfWeek) ? 1
+           : (currentFirstDayOfWeek == anotherFirstDayOfWeek) ? 0 : -1;
+  }
+ 
+  public static void main(String[] args) {
+    CalendarSubclass cs1 = new CalendarSubclass();
+    cs1.setTime(new Date());
+    // Date of last Sunday (before now)
+    cs1.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
+    // Wed Dec 31 19:00:00 EST 1969
+    CalendarSubclass cs2 = new CalendarSubclass();
+    // Expected to print true
+    System.out.println(cs1.after(cs2));
+  }
+ 
+  // Implementation of other Calendar abstract methods
+}","public boolean after(Object when) {
+  return when instanceof Calendar
+         && compareTo((Calendar) when) > 0;
+}"
+JAVA,객체 지향 (OBJ),힙 오염을 방지하십시오.,,"class ListUtility {
+  private static void addToList(List list, Object obj) {
+    list.add(obj); // Unchecked warning
+  }
+ 
+  public static void main(String[] args) {
+    List<String> list = new ArrayList<String> ();
+    addToList(list, 42);
+    System.out.println(list.get(0));  // Throws ClassCastException
+  }
+}","class ListUtility {
+  private static void addToList(List<String> list, String str) {
+    list.add(str);     // No warning generated
+  }
+ 
+  public static void main(String[] args) {
+    List<String> list = new ArrayList<String> ();
+    addToList(list, ""42"");
+    System.out.println(list.get(0));
+  }
+}"
+JAVA,객체 지향 (OBJ),힙 오염을 방지하십시오.,,"class ListUtility {
+  private static void addToList(List list, Object obj) {
+    list.add(obj); // Unchecked warning
+  }
+ 
+  public static void main(String[] args) {
+    List<String> list = new ArrayList<String> ();
+    addToList(list, 42);
+    System.out.println(list.get(1));  // Throws ClassCastException
+  }
+}","class ListUtility {
+  private static void addToList(List list, Object obj) {
+    list.add(obj); // Unchecked warning, also throws ClassCastException
+  }
+ 
+  public static void main(String[] args) {
+    List<String> list = new ArrayList<String> ();
+    List<String> checkedList = Collections.checkedList(list, String.class);
+    addToList(checkedList, 42);
+    System.out.println(list.get(0));
+  }
+}"
+JAVA,객체 지향 (OBJ),힙 오염을 방지하십시오.,,"class ListAdder {
+  @SuppressWarnings(""unchecked"")
+  private static void addToList(List list, Object obj) {
+    list.add(obj);  // Unchecked warning suppressed
+  }
+ 
+  private static <T> void printNum(T type) {
+    if (!(type instanceof Integer || type instanceof Double)) {
+      System.out.println(""Cannot print in the supplied type"");
+    }
+    List<T> list = new ArrayList<T>();
+    addToList(list, 42);
+    System.out.println(list.get(0));
+  }
+ 
+  public static void main(String[] args) {
+    double d = 42;
+    int i = 42;
+    System.out.println(d);
+    ListAdder.printNum(d);
+    System.out.println(i);
+    ListAdder.printNum(i);
+  }
+}","class ListAdder {
+  private static <T> void addToList(List<T> list, T t) {
+    list.add(t);     // No warning generated
+  }
+ 
+  private static <T> void printNum(T type) {
+    if (type instanceof Integer) {
+      List<Integer> list = new ArrayList<Integer>();
+      addToList(list, 42);
+      System.out.println(list.get(0));
+    }
+    else if (type instanceof Double) {
+      List<Double> list = new ArrayList<Double>();
+ 
+      addToList(list, 42.0);  // Will not compile with 42 instead of 42.0
+ 
+      System.out.println(list.get(0));
+    } else {
+      System.out.println(""Cannot print in the supplied type"");
+    }
+  }
+ 
+  public static void main(String[] args) {
+    double d = 42;
+    int i = 42;
+    System.out.println(d);
+    ListAdder.printNum(d);
+    System.out.println(i);
+    ListAdder.printNum(i);
+  }
+}"
+JAVA,객체 지향 (OBJ),힙 오염을 방지하십시오.,,"class ListModifierExample {
+  public static void modify(List<String>... list) {
+    Object[] objectArray = list;
+    objectArray[1] = Arrays.asList(42);   // Pollutes list, no warning
+ 
+    for (List<String> ls : list) {
+      for (String string : ls) {          // ClassCastException on 42
+        System.out.println(string);
+      }
+    }
+  }
+  
+  public static void main(String[] args) {
+    List<String> s = Arrays.asList(""foo"", ""bar"");
+    List<String> s2 = Arrays.asList(""baz"", ""quux"");
+    modify( s, s2);                       // Unchecked varargs warning
+  }
+}","class ListModifierExample {
+  public static void modify(List<List<String>> list) {
+    list.set( 1, Arrays.asList(""forty-two"")); // No warning
+ 
+    for (List<String> ls : list) {
+      for (String string : ls) {            // ClassCastException on 42
+        System.out.println(string);
+      }
+    }
+  }
+  
+  public static void main(String[] args) {
+    List<String> s = Arrays.asList(""foo"", ""bar"");
+    List<String> s2 = Arrays.asList(""baz"", ""quux"");
+    List<List<String>> list = new ArrayList<List<String>>();
+    list.add(s);
+    list.add(s2);
+    modify(list);
+  }
+}"
+JAVA,객체 지향 (OBJ),힙 오염을 방지하십시오.,,"class ListModifierExample {
+  public static void modify(List<String>[] list) {
+    Object[] objectArray = list;          // Valid
+    objectArray[1] = Arrays.asList(42);   // Pollutes list, no warning
+ 
+    for (List<String> ls : list) {
+      for (String string : ls) {          // ClassCastException on 42
+        System.out.println(string);
+      }
+    }
+  }
+  
+  public static void main(String[] args) {
+    List<String> s = Arrays.asList(""foo"", ""bar"");
+    List<String> s2 = Arrays.asList(""baz"", ""quux"");
+    List list[] = {s, s2};
+    modify(list);                         // Unchecked conversion warning
+  }
+}","class ListModifierExample {
+  public static void modify(List<List<String>> list) {
+    list.set( 1, Arrays.asList(""forty-two"")); // No warning
+ 
+    for (List<String> ls : list) {
+      for (String string : ls) {            // ClassCastException on 42
+        System.out.println(string);
+      }
+    }
+  }
+  
+  public static void main(String[] args) {
+    List<String> s = Arrays.asList(""foo"", ""bar"");
+    List<String> s2 = Arrays.asList(""baz"", ""quux"");
+    List<List<String>> list = new ArrayList<List<String>>();
+    list.add(s);
+    list.add(s3);
+    modify(list);
+  }
+}"
+JAVA,객체 지향 (OBJ),신뢰할 수 없는 코드에 인스턴스를 안전하게 전달할 수 있도록 복사 기능을 갖춘 변경 가능한 클래스를 제공하십시오.,,"public final class MutableClass {
+  private Date date;
+ 
+  public MutableClass(Date d) {
+    this.date = d;
+  }
+ 
+  public void setDate(Date d) {
+    this.date = d;
+  }
+ 
+  public Date getDate() {
+    return date;
+  }
+}","public final class MutableClass { // Copy constructor
+  private final Date date;
+ 
+  public MutableClass(MutableClass mc)  {
+    this.date = new Date(mc.date.getTime());
+  }
+ 
+  public MutableClass(Date d) {
+    this.date = new Date(d.getTime());  // Make defensive copy
+  }
+ 
+  public Date getDate() {
+    return (Date) date.clone(); // Copy and return
+  }
+}"
+JAVA,객체 지향 (OBJ),신뢰할 수 없는 코드에 인스턴스를 안전하게 전달할 수 있도록 복사 기능을 갖춘 변경 가능한 클래스를 제공하십시오.,,"public final class MutableClass {
+  private Date date;
+ 
+  public MutableClass(Date d) {
+    this.date = d;
+  }
+ 
+  public void setDate(Date d) {
+    this.date = d;
+  }
+ 
+  public Date getDate() {
+    return date;
+  }
+}","class MutableClass {
+  private final Date date;
+ 
+  private MutableClass(Date d) { // Noninstantiable and nonsubclassable
+    this.date = new Date(d.getTime());  // Make defensive copy
+  }
+ 
+  public Date getDate() {
+    return (Date) date.clone(); // Copy and return
+  }
+ 
+  public static MutableClass getInstance(MutableClass mc)  {
+    return new MutableClass(mc.getDate());
+  }
+}"
+JAVA,객체 지향 (OBJ),신뢰할 수 없는 코드에 인스턴스를 안전하게 전달할 수 있도록 복사 기능을 갖춘 변경 가능한 클래스를 제공하십시오.,,"public final class MutableClass {
+  private Date date;
+ 
+  public MutableClass(Date d) {
+    this.date = d;
+  }
+ 
+  public void setDate(Date d) {
+    this.date = d;
+  }
+ 
+  public Date getDate() {
+    return date;
+  }
+}","public final class MutableClass implements Cloneable {
+  private Date date;
+ 
+  public MutableClass(Date d) {
+    this.date = new Date(d.getTime());
+  }
+ 
+  public Date getDate() {
+    return (Date) date.clone();
+  }
+ 
+  public void setDate(Date d) {
+    this.date = (Date) d.clone();
+  }
+ 
+  public Object clone() throws CloneNotSupportedException {
+    final MutableClass cloned = (MutableClass) super.clone();
+    cloned.date = (Date) date.clone();  // Manually copy mutable Date object
+    return cloned;
+  }
+}"
+JAVA,객체 지향 (OBJ),신뢰할 수 없는 코드에 인스턴스를 안전하게 전달할 수 있도록 복사 기능을 갖춘 변경 가능한 클래스를 제공하십시오.,,"public final class MutableClass {
+  private Date date;
+ 
+  public MutableClass(Date d) {
+    this.date = d;
+  }
+ 
+  public void setDate(Date d) {
+    this.date = d;
+  }
+ 
+  public Date getDate() {
+    return date;
+  }
+}","public final class MutableClass implements Cloneable {
+  private final Date date; // final field
+ 
+  public MutableClass(Date d) {
+    this.date = new Date(d.getTime());  // Copy in
+  }
+ 
+  public Date getDate() {
+    return (Date) date.clone(); // Copy and return
+  }
+ 
+  public Object clone() {
+    Date d = (Date) date.clone();
+    MutableClass cloned = new MutableClass(d);
+    return cloned;
+  }
+}"
+JAVA,객체 지향 (OBJ),신뢰할 수 없는 코드에 인스턴스를 안전하게 전달할 수 있도록 복사 기능을 갖춘 변경 가능한 클래스를 제공하십시오.,,"public final class MutableClass {
+  private Date date;
+ 
+  public MutableClass(Date d) {
+    this.date = d;
+  }
+ 
+  public void setDate(Date d) {
+    this.date = d;
+  }
+ 
+  public Date getDate() {
+    return date;
+  }
+}","class UnmodifiableDateView extends Date {
+  private Date date;
+ 
+  public UnmodifiableDateView(Date date) {
+    this.date = date;
+  }
+ 
+  public void setTime(long date) {
+    throw new UnsupportedOperationException();
+  }
+ 
+  // Override all other mutator methods to throw UnsupportedOperationException
+}
+ 
+public final class MutableClass {
+  private Date date;
+ 
+  public MutableClass(Date d) {
+    this.date = d;
+  }
+ 
+  public void setDate(Date d) {
+    this.date = (Date) d.clone();
+  }
+ 
+  public UnmodifiableDateView getDate() {
+    return new UnmodifiableDateView(date);
+  }
+}"
+JAVA,객체 지향 (OBJ),private한 변경 가능한 클래스 멤버에 대한 참조를 반환하지 마십시오.,,"class MutableClass {
+  private Date d;
+ 
+  public MutableClass() {
+    d = new Date();
+  }
+ 
+  public Date getDate() {
+    return d;
+  }
+}","public Date getDate() {
+  return (Date)d.clone();
+}"
+JAVA,객체 지향 (OBJ),private한 변경 가능한 클래스 멤버에 대한 참조를 반환하지 마십시오.,,"class MutableClass {
+  private Date[] date;
+ 
+  public MutableClass() {
+    date = new Date[20];
+    for (int i = 0; i < date.length; i++) {
+      date[i] = new Date();
+    }
+  }
+ 
+  public Date[] getDate() {
+    return date; // Or return date.clone()
+  }
+}","class MutableClass {
+  private Date[] date;
+ 
+  public MutableClass() {
+    date = new Date[20];
+    for(int i = 0; i < date.length; i++) {
+      date[i] = new Date();
+    }
+  }
+ 
+  public Date[] getDate() {
+    Date[] dates = new Date[date.length];
+    for (int i = 0; i < date.length; i++) {
+      dates[i] = (Date) date[i].clone();
+    }
+    return dates;
+  }
+}"
+JAVA,객체 지향 (OBJ),private한 변경 가능한 클래스 멤버에 대한 참조를 반환하지 마십시오.,,"class ReturnRef {
+  // Internal state, may contain sensitive data
+  private Hashtable<Integer,String> ht = new Hashtable<Integer,String>();
+ 
+  private ReturnRef() {
+    ht.put(1, ""123-45-6666"");
+  }
+ 
+  public Hashtable<Integer,String> getValues(){
+    return ht;
+  }
+ 
+  public static void main(String[] args) {
+    ReturnRef rr = new ReturnRef();
+    Hashtable<Integer, String> ht1 = rr.getValues(); // Prints sensitive data 123-45-6666
+    ht1.remove(1);                                   // Untrusted caller can remove entries
+    Hashtable<Integer, String> ht2 = rr.getValues(); // Now prints null; original entry is removed
+  }
+}","class ReturnRef {
+  // ...
+  private Hashtable<Integer,String> getValues(){
+    return (Hashtable<Integer, String>) ht.clone(); // Shallow copy
+  }
+ 
+  public static void main(String[] args) {
+    ReturnRef rr = new ReturnRef();
+    // Prints nonsensitive data
+    Hashtable<Integer,String> ht1 = rr.getValues();
+    // Untrusted caller can only modify copy
+    ht1.remove(1);
+    // Prints nonsensitive data
+    Hashtable<Integer,String> ht2 = rr.getValues();
+  }
+}"
+JAVA,객체 지향 (OBJ),private한 변경 가능한 클래스 멤버에 대한 참조를 반환하지 마십시오.,,"class MutableClass {
+  private Date d;
+ 
+  public MutableClass() {
+    d = new Date();
+  }
+ 
+  public Date getDate() {
+    return d;
+  }
+}","public Date getDate() {
+  return (Date)d.clone();
+}"
+JAVA,객체 지향 (OBJ),private한 변경 가능한 클래스 멤버에 대한 참조를 반환하지 마십시오.,,"class MutableClass {
+  private Date[] date;
+ 
+  public MutableClass() {
+    date = new Date[20];
+    for (int i = 0; i < date.length; i++) {
+      date[i] = new Date();
+    }
+  }
+ 
+  public Date[] getDate() {
+    return date; // Or return date.clone()
+  }
+}","
+class MutableClass {
+  private Date[] date;
+ 
+  public MutableClass() {
+    date = new Date[20];
+    for(int i = 0; i < date.length; i++) {
+      date[i] = new Date();
+    }
+  }
+ 
+  public Date[] getDate() {
+    Date[] dates = new Date[date.length];
+    for (int i = 0; i < date.length; i++) {
+      dates[i] = (Date) date[i].clone();
+    }
+    return dates;
+  }
+}"
+JAVA,객체 지향 (OBJ),private한 변경 가능한 클래스 멤버에 대한 참조를 반환하지 마십시오.,,"class ReturnRef {
+  // Internal state, may contain sensitive data
+  private Hashtable<Integer,String> ht = new Hashtable<Integer,String>();
+ 
+  private ReturnRef() {
+    ht.put(1, ""123-45-6666"");
+  }
+ 
+  public Hashtable<Integer,String> getValues(){
+    return ht;
+  }
+ 
+  public static void main(String[] args) {
+    ReturnRef rr = new ReturnRef();
+    Hashtable<Integer, String> ht1 = rr.getValues(); // Prints sensitive data 123-45-6666
+    ht1.remove(1);                                   // Untrusted caller can remove entries
+    Hashtable<Integer, String> ht2 = rr.getValues(); // Now prints null; original entry is removed
+  }
+}","class ReturnRef {
+  // ...
+  private Hashtable<Integer,String> getValues(){
+    return (Hashtable<Integer, String>) ht.clone(); // Shallow copy
+  }
+ 
+  public static void main(String[] args) {
+    ReturnRef rr = new ReturnRef();
+    // Prints nonsensitive data
+    Hashtable<Integer,String> ht1 = rr.getValues();
+    // Untrusted caller can only modify copy
+    ht1.remove(1);
+    // Prints nonsensitive data
+    Hashtable<Integer,String> ht2 = rr.getValues();
+  }
+}"
+JAVA,객체 지향 (OBJ),변경 가능한 입력과 변경 가능한 내부 구성 요소를 방어적으로 복사하십시오.,,"public final class MutableDemo {
+  // java.net.HttpCookie is mutable
+  public void useMutableInput(HttpCookie cookie) {
+    if (cookie == null) {
+       throw new NullPointerException();
+    }
+ 
+    // Check whether cookie has expired
+    if (cookie.hasExpired()) {
+      // Cookie is no longer valid; handle condition by throwing an exception
+    }
+ 
+    // Cookie may have expired since time of check
+    doLogic(cookie);
+  }
+}","public final class MutableDemo {
+  // java.net.HttpCookie is mutable
+  public void useMutableInput(HttpCookie cookie) {
+    if (cookie == null) {
+      throw new NullPointerException();
+    }
+ 
+    // Create copy
+    cookie = (HttpCookie)cookie.clone();
+ 
+    // Check whether cookie has expired
+    if (cookie.hasExpired()) {
+      // Cookie is no longer valid; handle condition by throwing an exception
+    }
+ 
+    doLogic(cookie);
+  }
+}"
+JAVA,객체 지향 (OBJ),변경 가능한 입력과 변경 가능한 내부 구성 요소를 방어적으로 복사하십시오.,,"public final class MutableDemo {
+  // java.net.HttpCookie is mutable
+  public void useMutableInput(HttpCookie cookie) {
+    if (cookie == null) {
+       throw new NullPointerException();
+    }
+ 
+    // Check whether cookie has expired
+    if (cookie.hasExpired()) {
+      // Cookie is no longer valid; handle condition by throwing an exception
+    }
+ 
+    // Cookie may have expired since time of check
+    doLogic(cookie);
+  }
+}","public void deepCopy(int[] ints, HttpCookie[] cookies) {
+  if (ints == null || cookies == null) {
+    throw new NullPointerException();
+  }
+ 
+  // Shallow copy
+  int[] intsCopy = ints.clone();
+ 
+  // Deep copy
+  HttpCookie[] cookiesCopy = new HttpCookie[cookies.length];
+  for (int i = 0; i < cookies.length; i++) {
+    // Manually create copy of each element in array
+    cookiesCopy[i] = (HttpCookie)cookies[i].clone();
+  }
+  
+  doLogic(intsCopy, cookiesCopy);
+}"
+JAVA,객체 지향 (OBJ),변경 가능한 입력과 변경 가능한 내부 구성 요소를 방어적으로 복사하십시오.,,"// java.util.Collection is an interface
+public void copyInterfaceInput(Collection<String> collection) {
+  doLogic(collection.clone());
+}","public void copyInterfaceInput(Collection<String> collection) {
+  // Convert input to trusted implementation
+  collection = new ArrayList(collection);
+  doLogic(collection);
+}"
+JAVA,객체 지향 (OBJ),민감한 클래스는 스스로 복사되도록 허용해서는 안 됩니다.,,"class SensitiveClass {
+  private char[] filename;
+  private Boolean shared = false;
+ 
+  SensitiveClass(String filename) {
+    this.filename = filename.toCharArray();
+  }
+ 
+  final void replace() {
+    if (!shared) {
+      for(int i = 0; i < filename.length; i++) {
+        filename[i]= 'x' ;}
+    }
+  }
+ 
+  final String get() {
+    if (!shared) {
+      shared = true;
+      return String.valueOf(filename);
+    } else {
+      throw new IllegalStateException(""Failed to get instance"");
+    }
+  }
+ 
+  final void printFilename() {
+    System.out.println(String.valueOf(filename));
+  }
+}","class SensitiveClass {
+  // ...
+  public final SensitiveClass clone()
+                              throws CloneNotSupportedException {
+    throw new CloneNotSupportedException();
+  }
+}"
+JAVA,객체 지향 (OBJ),중첩 클래스에서 외부 클래스의 비공개 멤버를 노출하지 마십시오.,,"class Coordinates {
+  private int x;
+  private int y;
+ 
+  public class Point {
+    public void getPoint() {
+      System.out.println(""("" + x + "","" + y + "")"");
+    }
+  }
+}
+ 
+class AnotherClass {
+  public static void main(String[] args) {
+    Coordinates c = new Coordinates();
+    Coordinates.Point p = c.new Point();
+    p.getPoint();
+  }
+}","class Coordinates {
+  private int x;
+  private int y;
+ 
+  private class Point {
+    private void getPoint() {
+      System.out.println(""("" + x + "","" + y + "")"");
+    }
+  }
+}
+ 
+class AnotherClass {
+  public static void main(String[] args) {
+    Coordinates c = new Coordinates();
+    Coordinates.Point p = c.new Point();    // Fails to compile
+    p.getPoint();
+  }
+}"
+JAVA,객체 지향 (OBJ),클래스 이름이 아닌 클래스를 비교하십시오.,,"// Determine whether object auth has required/expected class object
+ if (auth.getClass().getName().equals(
+      ""com.application.auth.DefaultAuthenticationHandler"")) {
+   // ...
+}","// Determine whether object auth has required/expected class name
+ if (auth.getClass() == com.application.auth.DefaultAuthenticationHandler.class) {
+   // ...
+}"
+JAVA,객체 지향 (OBJ),클래스 이름이 아닌 클래스를 비교하십시오.,,"// Determine whether objects x and y have the same class name
+if (x.getClass().getName().equals(y.getClass().getName())) {
+  // Objects have the same class
+}","// Determine whether objects x and y have the same class
+if (x.getClass() == y.getClass()) {
+  // Objects have the same class
+}"
+JAVA,객체 지향 (OBJ),public static final이 아닌 필드를 사용하지 마십시오.,,"package org.apache.xpath.compiler;
+ 
+public class FunctionTable {
+  public static FuncLoader m_functions;
+}","public static final FuncLoader m_functions;
+// Initialize m_functions in a static initialization block"
+JAVA,객체 지향 (OBJ),public static final이 아닌 필드를 사용하지 마십시오.,,"class DataSerializer implements Serializable {
+  public static long serialVersionUID = 1973473122623778747L;
+  // ...
+}","
+class DataSerializer implements Serializable {
+  private static final long serialVersionUID = 1973473122623778747L;
+}"
+JAVA,객체 지향 (OBJ),생성자가 예외를 던지도록 허용하는 것에 유의하십시오.,,"public class BankOperations {
+  public BankOperations() {
+    if (!performSSNVerification()) {
+      throw new SecurityException(""Access Denied!"");
+    }
+  }
+ 
+  private boolean performSSNVerification() {
+    return false; // Returns true if data entered is valid, else false
+                  // Assume that the attacker always enters an invalid SSN
+  }
+ 
+  public void greet() {
+    System.out.println(""Welcome user! You may now use all the features."");
+  }
+}
+ 
+public class Storage {
+  private static BankOperations bop;
+ 
+  public static void store(BankOperations bo) {
+  // Store only if it is initialized
+    if (bop == null) {
+      if (bo == null) {
+        System.out.println(""Invalid object!"");
+        System.exit(1);
+      }
+      bop = bo;
+    }
+  }
+}
+ 
+public class UserApp {
+  public static void main(String[] args) {
+    BankOperations bo;
+    try {
+      bo = new BankOperations();
+    } catch (SecurityException ex) { bo = null; }
+ 
+    Storage.store(bo);
+    System.out.println(""Proceed with normal logic"");
+  }
+}","public final class BankOperations {
+  // ...
+}
+또는 
+public class BankOperations {
+  public final void finalize() {
+    // Do nothing
+  }
+}
+코드로 finalizer 공격을 방지할 수 있다."
+JAVA,객체 지향 (OBJ),생성자가 예외를 던지도록 허용하는 것에 유의하십시오.,,"public class Interceptor extends BankOperations {
+  private static Interceptor stealInstance = null;
+ 
+  public static Interceptor get() {
+    try {
+      new Interceptor();
+    } catch (Exception ex) {/* Ignore exception */}
+    try {
+      synchronized (Interceptor.class) {
+        while (stealInstance == null) {
+          System.gc();
+          Interceptor.class.wait(10);
+        }
+      }
+    } catch (InterruptedException ex) { return null; }
+    return stealInstance;
+  }
+ 
+  public void finalize() {
+    synchronized (Interceptor.class) {
+      stealInstance = this;
+      Interceptor.class.notify();
+    }
+    System.out.println(""Stole the instance in finalize of "" + this);
+  }
+}
+ 
+public class AttackerApp { // Invoke class and gain access
+                           // to the restrictive features
+  public static void main(String[] args) {
+    Interceptor i = Interceptor.get(); // Stolen instance
+ 
+    // Can store the stolen object even though this should have printed
+    // ""Invalid Object!""
+    Storage.store(i);
+ 
+    // Now invoke any instance method of BankOperations class
+    i.greet();
+ 
+    UserApp.main(args); // Invoke the original UserApp
+  }
+}","public final class BankOperations {
+  // ...
+}
+또는 
+public class BankOperations {
+  public final void finalize() {
+    // Do nothing
+  }
+}
+코드로 finalizer 공격을 방지할 수 있다."
+JAVA,객체 지향 (OBJ),생성자가 예외를 던지도록 허용하는 것에 유의하십시오.,,"public class BankOperations {
+  public BankOperations() {
+    if (!performSSNVerification()) {
+      throw new SecurityException(""Access Denied!"");
+    }
+  }
+ 
+  private boolean performSSNVerification() {
+    return false; // Returns true if data entered is valid, else false
+                  // Assume that the attacker always enters an invalid SSN
+  }
+ 
+  public void greet() {
+    System.out.println(""Welcome user! You may now use all the features."");
+  }
+}
+ 
+public class Storage {
+  private static BankOperations bop;
+ 
+  public static void store(BankOperations bo) {
+  // Store only if it is initialized
+    if (bop == null) {
+      if (bo == null) {
+        System.out.println(""Invalid object!"");
+        System.exit(1);
+      }
+      bop = bo;
+    }
+  }
+}
+ 
+public class UserApp {
+  public static void main(String[] args) {
+    BankOperations bo;
+    try {
+      bo = new BankOperations();
+    } catch (SecurityException ex) { bo = null; }
+ 
+    Storage.store(bo);
+    System.out.println(""Proceed with normal logic"");
+  }
+}","public class BankOperations {
+  public BankOperations() {
+    this(performSSNVerification());
+  }
+ 
+  private BankOperations(boolean secure) {
+    // secure is always true
+    // Constructor without any security checks
+  }
+ 
+  private static boolean performSSNVerification() {
+    // Returns true if data entered is valid, else throws a SecurityException
+    // Assume that the attacker just enters invalid SSN, so this method always throws the exception
+    throw new SecurityException(""Invalid SSN!"");
+  }
+ 
+  // ...remainder of BankOperations class definition
+}"
+JAVA,객체 지향 (OBJ),생성자가 예외를 던지도록 허용하는 것에 유의하십시오.,,"public class BankOperations {
+  public BankOperations() {
+    if (!performSSNVerification()) {
+      throw new SecurityException(""Access Denied!"");
+    }
+  }
+ 
+  private boolean performSSNVerification() {
+    return false; // Returns true if data entered is valid, else false
+                  // Assume that the attacker always enters an invalid SSN
+  }
+ 
+  public void greet() {
+    System.out.println(""Welcome user! You may now use all the features."");
+  }
+}
+ 
+public class Storage {
+  private static BankOperations bop;
+ 
+  public static void store(BankOperations bo) {
+  // Store only if it is initialized
+    if (bop == null) {
+      if (bo == null) {
+        System.out.println(""Invalid object!"");
+        System.exit(2);
+      }
+      bop = bo;
+    }
+  }
+}
+ 
+public class UserApp {
+  public static void main(String[] args) {
+    BankOperations bo;
+    try {
+      bo = new BankOperations();
+    } catch (SecurityException ex) { bo = null; }
+ 
+    Storage.store(bo);
+    System.out.println(""Proceed with normal logic"");
+  }
+}","class BankOperations {
+  private volatile boolean initialized = false;
+ 
+  public BankOperations() {
+    if (!performSSNVerification()) {
+      return;                // object construction failed
+    }
+ 
+    this.initialized = true; // Object construction successful
+  }
+ 
+  private boolean performSSNVerification() {
+    return false;
+  }
+ 
+  public void greet() {
+    if (!this.initialized) {
+      throw new SecurityException(""Invalid SSN!"");
+    }
+ 
+    System.out.println(
+        ""Welcome user! You may now use all the features."");
+  }
+}"
+JAVA,객체 지향 (OBJ),생성자가 예외를 던지도록 허용하는 것에 유의하십시오.,,"class Trade {
+  private static Stock s;
+  static {
+    try {
+      s = new Stock();
+    } catch (IOException e) {
+      /* Does not initialize s to a safe state */
+    }
+  }
+  // ...
+}",private static final Stock s;
+JAVA,객체 지향 (OBJ),변경 가능한 객체에 대한 참조가 노출되지 않도록 하십시오.,,public static final SomeType [] SOMETHINGS = { ... };,"private static final SomeType [] SOMETHINGS = { ... };
+public static final SomeType [] somethings() {
+  return SOMETHINGS.clone();
+}"
+JAVA,객체 지향 (OBJ),변경 가능한 객체에 대한 참조가 노출되지 않도록 하십시오.,,"private static final SomeType [] SOMETHINGS = { ... };
+public static final getSomethings() {return SOMETHINGS;}","private static final SomeType [] THE_THINGS = { ... };
+public static final List<SomeType> SOMETHINGS =
+  Collections.unmodifiableList(Arrays.asList(THE_THINGS));"
+JAVA,"Methods (MET), 메서드",메서드의 인수를 검증하십시오.,,"private Object myState = null;
+ 
+// Sets some internal state in the library
+void setState(Object state) {
+  myState = state;
+}
+ 
+// Performs some action using the state passed earlier
+void useState() {
+  // Perform some action here
+}","private Object myState = null;
+ 
+// Sets some internal state in the library
+void setState(Object state) {
+  if (state == null) {
+    // Handle null state
+  }
+ 
+  // Defensive copy here when state is mutable
+ 
+  if (isInvalidState(state)) {
+    // Handle invalid state
+  }
+  myState = state;
+}
+ 
+// Performs some action using the state passed earlier
+void useState() {
+  if (myState == null) {
+    // Handle no state (e.g., null) condition
+  }
+  // ...
+}"
+JAVA,"Methods (MET), 메서드",메서드의 인수를 검증하기 위해 어설션을 절대 사용하지 마십시오.,"CWE-617, Reachable Assertion","public static int getAbsAdd(int x, int y) {
+  return Math.abs(x) + Math.abs(y);
+}
+getAbsAdd(Integer.MIN_VALUE, 1);","public static int getAbsAdd(int x, int y) {
+  if (x == Integer.MIN_VALUE || y == Integer.MIN_VALUE) {
+    throw new IllegalArgumentException();
+  }
+  int absX = Math.abs(x);
+  int absY = Math.abs(y);
+  if (absX > Integer.MAX_VALUE - absY) {
+    throw new IllegalArgumentException();
+  }
+  return absX + absY;
+}"
+JAVA,"Methods (MET), 메서드",메서드의 인수를 검증하기 위해 어설션을 절대 사용하지 마십시오.,"CWE-617, Reachable Assertion","public static int getAbsAdd(int x, int y) {
+  assert x != Integer.MIN_VALUE;
+  assert y != Integer.MIN_VALUE;
+  int absX = Math.abs(x);
+  int absY = Math.abs(y);
+  assert (absX <= Integer.MAX_VALUE - absY);
+  return absX + absY;
+}","public static int getAbsAdd(int x, int y) {
+  if (x == Integer.MIN_VALUE || y == Integer.MIN_VALUE) {
+    throw new IllegalArgumentException();
+  }
+  int absX = Math.abs(x);
+  int absY = Math.abs(y);
+  if (absX > Integer.MAX_VALUE - absY) {
+    throw new IllegalArgumentException();
+  }
+  return absX + absY;
+}"
+JAVA,"Methods (MET), 메서드",더 이상 사용되지 않거나 폐기된 클래스나 메서드를 사용하지 마십시오.,,java.lang.Character.isJavaLetter(),"java.lang.Character.isJavaIdentifierStart()
+"
+JAVA,"Methods (MET), 메서드",더 이상 사용되지 않거나 폐기된 클래스나 메서드를 사용하지 마십시오.,,"java.lang.Character.isJavaLetterOrDigit()
+",java.lang.Character.isJavaIdentifierPart()
+JAVA,"Methods (MET), 메서드",더 이상 사용되지 않거나 폐기된 클래스나 메서드를 사용하지 마십시오.,,java.lang.Character.isSpace(),java.lang.Character.isWhitespace()
+JAVA,"Methods (MET), 메서드",더 이상 사용되지 않거나 폐기된 클래스나 메서드를 사용하지 마십시오.,,java.lang.Class.newInstance(),java.lang.reflect.Constructor.newInstance()
+JAVA,"Methods (MET), 메서드",더 이상 사용되지 않거나 폐기된 클래스나 메서드를 사용하지 마십시오.,,java.util.Date (many methods),java.util.Calendar
+JAVA,"Methods (MET), 메서드",더 이상 사용되지 않거나 폐기된 클래스나 메서드를 사용하지 마십시오.,,"java.util.Dictionary<K,V>","java.util.Map<K,V>"
+JAVA,"Methods (MET), 메서드",더 이상 사용되지 않거�� 폐기된 클래스나 메서드를 사용하지 마십시오.,,java.util.Properties.save(),java.util.Properties.store()
+JAVA,"Methods (MET), 메서드",더 이상 사용되지 않거나 폐기된 클래스나 메서드를 사용하지 마십시오.,,java.lang.Thread.run(),java.lang.Thread.start()
+JAVA,"Methods (MET), 메서드",더 이상 사용되지 않거나 폐기된 클래스나 메서드를 사용하지 마십시오.,,java.lang.Thread.stop(),java.lang.Thread.interrupt()
+JAVA,"Methods (MET), 메서드",더 이상 사용되지 않거나 폐기된 클래스나 메서드를 사용하지 마십시오.,,java.lang.ThreadGroup (many methods),java.util.concurrent.Executor
+JAVA,"Methods (MET), 메서드",더 이상 사용되지 않거나 폐기된 클래스나 메서드를 사용하지 마십시오.,,java.util.Date,java.time (since Java 8)
+JAVA,"Methods (MET), 메서드",보안 검사를 수행하는 메서드는 private 또는 final로 선언되어야 합니다.,,"public void readSensitiveFile() {
+  try {
+    SecurityManager sm = System.getSecurityManager();
+    if (sm != null) {  // Check for permission to read file
+      sm.checkRead(""/temp/tempFile"");
+    }
+    // Access the file
+  } catch (SecurityException se) {
+    // Log exception
+  }
+}","public final void readSensitiveFile() {
+  try {
+    SecurityManager sm = System.getSecurityManager();
+    if (sm != null) {  // Check for permission to read file
+      sm.checkRead(""/temp/tempFile"");
+    }
+    // Access the file
+  } catch (SecurityException se) {
+    // Log exception
+  }
+}"
+JAVA,"Methods (MET), 메서드",보안 검사를 수행하는 메서드는 private 또는 final로 선언되어야 합니다.,,"public void readSensitiveFile() {
+  try {
+    SecurityManager sm = System.getSecurityManager();
+    if (sm != null) {  // Check for permission to read file
+      sm.checkRead(""/temp/tempFile"");
+    }
+    // Access the file
+  } catch (SecurityException se) {
+    // Log exception
+  }
+}","private void readSensitiveFile() {
+  try {
+    SecurityManager sm = System.getSecurityManager();
+    if (sm != null) {  // Check for permission to read file
+      sm.checkRead(""/temp/tempFile"");
+    }
+    // Access the file
+  } catch (SecurityException se) {
+    // Log exception
+  }
+}"
+JAVA,"Methods (MET), 메서드",오버라이드 또는 숨겨진 메서드의 접근성을 높이지 마십시오.,CWE-487,"class Super {
+  protected void doLogic() {
+    System.out.println(""Super invoked"");
+  }
+}
+ 
+public class Sub extends Super {
+  public void doLogic() {
+    System.out.println(""Sub invoked"");
+    // Do sensitive operations
+  }
+}","class Super {
+  protected final void doLogic() { // Declare as final
+    System.out.println(""Super invoked"");
+    // Do sensitive operations
+  }
+}"
+JAVA,"Methods (MET), 메서드",생성자가 재정의 가능한 메서드를 호출하지 않도록 하십시오.,,"class SuperClass {
+  public SuperClass () {
+    doLogic();
+  }
+ 
+  public void doLogic() {
+    System.out.println(""This is superclass!"");
+  }
+}
+ 
+class SubClass extends SuperClass {
+  private String color = ""red"";
+ 
+  public void doLogic() {
+    System.out.println(""This is subclass! The color is :"" + color);
+    // ...
+  }
+}
+ 
+public class Overridable {
+  public static void main(String[] args) {
+    SuperClass bc = new SuperClass();
+    // Prints ""This is superclass!""
+    SuperClass sc = new SubClass();
+    // Prints ""This is subclass! The color is :null""
+  }
+}","class SuperClass {
+  public SuperClass() {
+    doLogic();
+  }
+ 
+  public final void doLogic() {
+    System.out.println(""This is superclass!"");
+  }
+}"
+JAVA,"Methods (MET), 메서드",clone()에서 오버라이드 가능한 메서드를 호출하지 마세요.,,"class CloneExample implements Cloneable {
+  HttpCookie[] cookies;
+ 
+  CloneExample(HttpCookie[] c) {
+    cookies = c;
+  }
+ 
+  public Object clone() throws CloneNotSupportedException {
+    final CloneExample clone = (CloneExample) super.clone();
+    clone.doSomething(); // Invokes overridable method
+    clone.cookies = clone.deepCopy();
+    return clone;
+  }
+ 
+  void doSomething() { // Overridable
+    for (int i = 0; i < cookies.length; i++) {
+      cookies[i].setValue("""" + i);
+    }
+  }
+ 
+  HttpCookie[] deepCopy() {
+    if (cookies == null) {
+      throw new NullPointerException();
+    }
+ 
+    // Deep copy
+    HttpCookie[] cookiesCopy = new HttpCookie[cookies.length];
+ 
+    for (int i = 0; i < cookies.length; i++) {
+      // Manually create a copy of each element in array
+      cookiesCopy[i] = (HttpCookie) cookies[i].clone();
+    }
+    return cookiesCopy;
+  }
+}
+ 
+class Sub extends CloneExample {
+  Sub(HttpCookie[] c) {
+    super(c);
+  }
+ 
+  public Object clone() throws CloneNotSupportedException {
+    final Sub clone = (Sub) super.clone();
+    clone.doSomething();
+    return clone;
+  }
+ 
+  void doSomething() { // Erroneously executed
+    for (int i = 0;i < cookies.length; i++) {
+      cookies[i].setDomain(i + "".foo.com"");
+    }
+  }
+ 
+  public static void main(String[] args)
+      throws CloneNotSupportedException {
+    HttpCookie[] hc = new HttpCookie[20];
+    for (int i = 0 ; i < hc.length; i++){
+      hc[i] = new HttpCookie(""cookie"" + i,"""" + i);
+    }
+    CloneExample bc = new Sub(hc);
+    bc.clone();
+  }
+}","class CloneExample implements Cloneable {
+  final void doSomething() {
+    // ...
+  }
+  final HttpCookie[] deepCopy() {
+    // ...
+  }
+ 
+  // ...
+}"
+JAVA,"Methods (MET), 메서드",슈퍼클래스나 슈퍼인터페이스에 선언된 메서드를 숨기는 클래스 메서드를 선언하지 마십시오.,,"class GrantAccess {
+  public static void displayAccountStatus() {
+    System.out.println(""Account details for admin: XX"");
+  }
+}
+ 
+class GrantUserAccess extends GrantAccess {
+  public static void displayAccountStatus() {
+    System.out.println(""Account details for user: XX"");
+  }
+}
+ 
+public class StatMethod {
+  public static void choose(String username) {
+    GrantAccess admin = new GrantAccess();
+    GrantAccess user = new GrantUserAccess();
+    if (username.equals(""admin"")) {
+      admin.displayAccountStatus();
+    } else {
+      user.displayAccountStatus();
+    }
+  }
+ 
+  public static void main(String[] args) {
+    choose(""user"");
+  }
+}","class GrantAccess {
+  public void displayAccountStatus() {
+    System.out.print(""Account details for admin: XX"");
+  }
+}
+ 
+class GrantUserAccess extends GrantAccess {
+  @Override
+  public void displayAccountStatus() {
+    System.out.print(""Account details for user: XX"");
+  }
+}
+ 
+public class StatMethod {
+  public static void choose(String username) {
+    GrantAccess admin = new GrantAccess();
+    GrantAccess user = new GrantUserAccess();
+ 
+    if (username.equals(""admin"")) {
+      admin.displayAccountStatus();
+    } else {
+      user.displayAccountStatus();
+    }
+  }
+ 
+  public static void main(String[] args) {
+    choose(""user"");
+  }
+}"
+JAVA,"Methods (MET), 메서드",equals() 메서드를 오버라이드할 때 동등성 계약을 유지하십시오.,"CWE-697, 잘못된 비교","public final class CaseInsensitiveString {
+  private String s;
+ 
+  public CaseInsensitiveString(String s) {
+    if (s == null) {
+      throw new NullPointerException();
+    }
+    this.s = s;
+  }
+ 
+  // This method violates symmetry
+  public boolean equals(Object o) {
+    if (o instanceof CaseInsensitiveString) {
+      return s.equalsIgnoreCase(((CaseInsensitiveString)o).s);
+    }
+ 
+    if (o instanceof String) {
+      return s.equalsIgnoreCase((String)o);
+    }
+    return false;
+  }
+ 
+  // Comply with MET09-J
+  public int hashCode() {/* ... */}
+ 
+  public static void main(String[] args) {
+    CaseInsensitiveString cis = new CaseInsensitiveString(""Java"");
+    String s = ""java"";
+    System.out.println(cis.equals(s)); // Returns true
+    System.out.println(s.equals(cis)); // Returns false
+  }
+}","public final class CaseInsensitiveString {
+  private String s;
+ 
+  public CaseInsensitiveString(String s) {
+    if (s == null) {
+      throw new NullPointerException();
+    }
+    this.s = s;
+  }
+ 
+  public boolean equals(Object o) {
+    return o instanceof CaseInsensitiveString &&
+        ((CaseInsensitiveString)o).s.equalsIgnoreCase(s);
+  }
+ 
+  public int hashCode() {/* ... */}
+ 
+  public static void main(String[] args) {
+    CaseInsensitiveString cis = new CaseInsensitiveString(""Java"");
+    String s = ""java"";
+    System.out.println(cis.equals(s)); // Returns false now
+    System.out.println(s.equals(cis)); // Returns false now
+  }
+}"
+JAVA,"Methods (MET), 메서드",equals() 메서드를 오버라이드할 때 동등성 계약을 유지하십시오.,"CWE-697, 잘못된 비교","public class Card {
+  private final int number;
+ 
+  public Card(int number) {
+    this.number = number;
+  }
+ 
+  public boolean equals(Object o) {
+    if (!(o instanceof Card)) {
+      return false;
+    }
+ 
+    Card c = (Card)o;
+    return c.number == number;
+  }
+ 
+  public int hashCode() {/* ... */}
+ 
+}
+ 
+class XCard extends Card {
+  private String type;
+  public XCard(int number, String type) {
+    super(number);
+    this.type = type;
+  }
+ 
+  public boolean equals(Object o) {
+    if (!(o instanceof Card)) {
+      return false;
+    }
+ 
+    // Normal Card, do not compare type
+    if (!(o instanceof XCard)) {
+      return o.equals(this);
+    }
+ 
+    // It is an XCard, compare type as well
+    XCard xc = (XCard)o;
+    return super.equals(o) && xc.type == type;
+  }
+ 
+  public int hashCode() {/* ... */}
+ 
+  public static void main(String[] args) {
+    XCard p1 = new XCard(1, ""type1"");
+    Card p2 = new Card(1);
+    XCard p3 = new XCard(1, ""type2"");
+    System.out.println(p1.equals(p2)); // Returns true
+    System.out.println(p2.equals(p3)); // Returns true
+    System.out.println(p1.equals(p3)); // Returns false
+                                       // violating transitivity
+  }
+}","class XCard {
+  private String type;
+  private Card card; // Composition
+ 
+  public XCard(int number, String type) {
+    card = new Card(number);
+    this.type = type;
+  }
+ 
+  public Card viewCard() {
+    return card;
+  }
+ 
+  public boolean equals(Object o) {
+    if (!(o instanceof XCard)) {
+      return false;
+    }
+ 
+    XCard cp = (XCard)o;
+    return cp.card.equals(card) && cp.type.equals(type);
+  }
+ 
+  public int hashCode() {/* ... */}
+ 
+  public static void main(String[] args) {
+    XCard p1 = new XCard(1, ""type1"");
+    Card p2 = new Card(1);
+    XCard p3 = new XCard(1, ""type2"");
+    XCard p4 = new XCard(1, ""type1"");
+    System.out.println(p1.equals(p2)); // Prints false
+    System.out.println(p2.equals(p3)); // Prints false
+    System.out.println(p1.equals(p3)); // Prints false
+    System.out.println(p1.equals(p4)); // Prints true
+  }
+}"
+JAVA,"Methods (MET), 메서드",equals() 메서드를 오버라이드할 때 동등성 계약을 유지하십시오.,"CWE-697, 잘못된 비교","public class Card {
+  private final int number;
+ 
+  public Card(int number) {
+    this.number = number;
+  }
+ 
+  public boolean equals(Object o) {
+    if (!(o instanceof Card)) {
+      return false;
+    }
+ 
+    Card c = (Card)o;
+    return c.number == number;
+  }
+ 
+  public int hashCode() {/* ... */}
+ 
+}
+ 
+class XCard extends Card {
+  private String type;
+  public XCard(int number, String type) {
+    super(number);
+    this.type = type;
+  }
+ 
+  public boolean equals(Object o) {
+    if (!(o instanceof Card)) {
+      return false;
+    }
+ 
+    // Normal Card, do not compare type
+    if (!(o instanceof XCard)) {
+      return o.equals(this);
+    }
+ 
+    // It is an XCard, compare type as well
+    XCard xc = (XCard)o;
+    return super.equals(o) && xc.type == type;
+  }
+ 
+  public int hashCode() {/* ... */}
+ 
+  public static void main(String[] args) {
+    XCard p1 = new XCard(1, ""type1"");
+    Card p2 = new Card(1);
+    XCard p3 = new XCard(1, ""type2"");
+    System.out.println(p1.equals(p2)); // Returns true
+    System.out.println(p2.equals(p3)); // Returns true
+    System.out.println(p1.equals(p4)); // Returns false
+                                       // violating transitivity
+  }
+}","public class Card {
+  private final int number;
+ 
+  public Card(int number) {
+    this.number = number;
+  }
+ 
+  public boolean equals(Object o) {
+    if (!(o.getClass() == this.getClass())) {
+      return false;
+    }
+ 
+    Card c = (Card)o;
+    return c.number == number;
+  }
+ 
+  public int hashCode() {/* ... */}
+ 
+}"
+JAVA,"Methods (MET), 메서드",equals() 메서드를 오버라이드할 때 동등성 계약을 유지하십시오.,"CWE-697, 잘못된 비교","public class Filter {
+  public static void main(String[] args) throws MalformedURLException {
+    final URL allowed = new URL(""http://mailwebsite.com"");
+    if (!allowed.equals(new URL(args[0]))) {
+      throw new SecurityException(""Access Denied"");
+    }
+    // Else proceed
+  }
+}","public class Filter {
+  public static void main(String[] args) throws MalformedURLException {
+    final URL allowed = new URL(""http://mailwebsite.com"");
+    if (!allowed.toString().equals(new URL(args[0]).toString())) {
+      throw new SecurityException(""Access Denied"");
+    }
+    // Else proceed
+  }
+}"
+JAVA,"Methods (MET), 메서드",equals() 메서드를 오버라이드할 때 동등성 계약을 유지하십시오.,"CWE-697, 잘못된 비교","public class Filter {
+  public static void main(String[] args) throws MalformedURLException {
+    final URL allowed = new URL(""http://mailwebsite.com"");
+    if (!allowed.equals(new URL(args[1]))) {
+      throw new SecurityException(""Access Denied"");
+    }
+    // Else proceed
+  }
+}","public class Filter {
+  public static void main(String[] args)
+                     throws MalformedURLException, URISyntaxException {
+    final URI allowed = new URI(""http://mailwebsite.com"");
+    if (!allowed.equals(new URI(args[0]))) {
+      throw new SecurityException(""Access Denied"");
+    }
+    // Else proceed
+  }
+}"
+JAVA,"Methods (MET), 메서드",equals() 메서드를 오버라이드할 때 동등성 계약을 유지하십시오.,"CWE-697, 잘못된 비교","private static boolean keysEqual(Key key1, Key key2) {
+  if (key1.equals(key2)) {
+    return true;
+  }
+  return false;
+}","private static boolean keysEqual(Key key1, Key key2) {
+  if (key1.equals(key2)) {
+    return true;
+  }
+ 
+  if (Arrays.equals(key1.getEncoded(), key2.getEncoded())) {
+    return true;
+  }
+ 
+  // More code for different types of keys here.
+  // For example, the following code can check if
+  // an RSAPrivateKey and an RSAPrivateCrtKey are equal:
+  if ((key1 instanceof RSAPrivateKey) &&
+      (key2 instanceof RSAPrivateKey)) {
+   
+    if ((((RSAKey)key1).getModulus().equals(
+         ((RSAKey)key2).getModulus())) &&
+       (((RSAPrivateKey) key1).getPrivateExponent().equals(
+        ((RSAPrivateKey) key2).getPrivateExponent()))) {
+      return true;
+    }
+  }
+  return false;
+}"
+JAVA,"Methods (MET), 메서드",equals() 메서드를 정의하는 클래스는 hashCode() 메서드도 정의해야 합니다.,CWE-581,"public final class CreditCard {
+  private final int number;
+ 
+  public CreditCard(int number) {
+    this.number = number;
+  }
+ 
+  public boolean equals(Object o) {
+    if (o == this) {
+      return true;
+    }
+    if (!(o instanceof CreditCard)) {
+      return false;
+    }
+    CreditCard cc = (CreditCard)o;
+    return cc.number == number;
+  }
+ 
+  public static void main(String[] args) {
+    Map<CreditCard, String> m = new HashMap<CreditCard, String>();
+    m.put(new CreditCard(100), ""4111111111111111"");
+    System.out.println(m.get(new CreditCard(100))); 
+  }
+}","public final class CreditCard {
+  private final int number;
+   
+  public CreditCard(int number) {
+    this.number = number;
+  }
+ 
+  public boolean equals(Object o) {
+    if (o == this) {
+      return true;
+    }
+    if (!(o instanceof CreditCard)) {
+      return false;
+    }
+    CreditCard cc = (CreditCard)o;
+    return cc.number == number;
+  }
+ 
+  public int hashCode() {
+    int result = 17;
+    result = 31 * result + number;
+    return result;
+  }
+ 
+  public static void main(String[] args) {
+    Map<CreditCard, String> m = new HashMap<CreditCard, String>();
+    m.put(new CreditCard(100), ""4111111111111111"");
+    System.out.println(m.get(new CreditCard(100)));
+  }
+}"
+JAVA,"Methods (MET), 메서드",compareTo() 메서드를 구현할 때 일반 계약을 준수하십시오.,"	
+CWE-573","class GameEntry implements Comparable {
+  public enum Roshambo {ROCK, PAPER, SCISSORS}
+  private Roshambo value;
+ 
+  public GameEntry(Roshambo value) {
+    this.value = value;
+  }
+ 
+  public int compareTo(Object that) {
+    if (!(that instanceof GameEntry)) {
+      throw new ClassCastException();
+    }
+    GameEntry t = (GameEntry) that;
+    return (value == t.value) ? 0
+      : (value == Roshambo.ROCK && t.value == Roshambo.PAPER) ? -1
+      : (value == Roshambo.PAPER && t.value == Roshambo.SCISSORS) ? -1
+      : (value == Roshambo.SCISSORS && t.value == Roshambo.ROCK) ? -1
+      : 1;
+  }
+}","class GameEntry {
+  public enum Roshambo {ROCK, PAPER, SCISSORS}
+  private Roshambo value;
+ 
+  public GameEntry(Roshambo value) {
+    this.value = value;
+  }
+ 
+  public int beats(Object that) {
+    if (!(that instanceof GameEntry)) {
+      throw new ClassCastException();
+    }
+    GameEntry t = (GameEntry) that;
+    return (value == t.value) ? 0
+      : (value == Roshambo.ROCK && t.value == Roshambo.PAPER) ? -1
+      : (value == Roshambo.PAPER && t.value == Roshambo.SCISSORS) ? -1
+      : (value == Roshambo.SCISSORS && t.value == Roshambo.ROCK) ? -1
+      : 1;
+  }
+}"
+JAVA,"Methods (MET), 메서드",비교 연산에 사용되는 키가 불변임을 보장하십시오.,,"// Mutable class Employee
+class Employee {
+  private String name;
+  private double salary;
+ 
+  Employee(String empName, double empSalary) {
+    this.name = empName;
+    this.salary = empSalary;
+  }
+ 
+  public void setEmployeeName(String empName) {
+    this.name = empName;
+  }
+ 
+  public void setSalary(double empSalary) {
+    this.salary = empSalary;
+  }
+ 
+  @Override
+  public boolean equals(Object o) {
+    if (!(o instanceof Employee)) {
+      return false;
+    }
+ 
+    Employee emp = (Employee)o;
+    return emp.name.equals(name);
+  }
+ 
+  public int hashCode() {/* ... */}
+ 
+}
+ 
+// Client code
+Map<Employee, Calendar> map =
+  new ConcurrentHashMap<Employee, Calendar>();
+// ...","// Mutable class Employee
+class Employee {
+  private String name;
+  private double salary;
+  private final long employeeID;  // Unique for each Employee
+ 
+  Employee(String name, double salary, long empID) {
+    this.name = name;
+    this.salary = salary;
+    this.employeeID = empID;
+  }
+ 
+  // ...
+ 
+  @Override
+  public boolean equals(Object o) {
+    if (!(o instanceof Employee)) {
+      return false;
+    }
+ 
+    Employee emp = (Employee)o;
+    return emp.employeeID == employeeID;
+  }
+}
+ 
+// Client code remains same
+Map<Employee, Calendar> map =
+  new ConcurrentHashMap<Employee, Calendar>();
+// ..."
+JAVA,"Methods (MET), 메서드",비교 연산에 사용되는 키가 불변임을 보장하십시오.,,"class MyKey implements Serializable {
+  // Does not override hashCode()
+}
+ 
+class HashSer {
+  public static void main(String[] args)
+                     throws IOException, ClassNotFoundException {
+    Hashtable<MyKey,String> ht = new Hashtable<MyKey, String>();
+    MyKey key = new MyKey();
+    ht.put(key, ""Value"");
+    System.out.println(""Entry: "" + ht.get(key));
+    // Retrieve using the key, works
+ 
+    // Serialize the Hashtable object
+    FileOutputStream fos = new FileOutputStream(""hashdata.ser"");
+    ObjectOutputStream oos = new ObjectOutputStream(fos);
+    oos.writeObject(ht);
+    oos.close();
+ 
+    // Deserialize the Hashtable object
+    FileInputStream fis = new FileInputStream(""hashdata.ser"");
+    ObjectInputStream ois = new ObjectInputStream(fis);
+    Hashtable<MyKey, String> ht_in =
+        (Hashtable<MyKey, String>)(ois.readObject());
+    ois.close();
+ 
+    if (ht_in.contains(""Value""))
+      // Check whether the object actually exists in the hash table
+      System.out.println(""Value was found in deserialized object."");
+ 
+    if (ht_in.get(key) == null) // Gets printed
+      System.out.println(
+          ""Object was not found when retrieved using the key."");
+  }
+}","class HashSer {
+  public static void main(String[] args)
+                     throws IOException, ClassNotFoundException {
+    Hashtable<Integer, String> ht = new Hashtable<Integer, String>();
+    ht.put(new Integer(1), ""Value"");
+    System.out.println(""Entry: "" + ht.get(1)); // Retrieve using the key
+ 
+    // Serialize the Hashtable object
+    FileOutputStream fos = new FileOutputStream(""hashdata.ser"");
+    ObjectOutputStream oos = new ObjectOutputStream(fos);
+    oos.writeObject(ht);
+    oos.close();
+ 
+    // Deserialize the Hashtable object
+    FileInputStream fis = new FileInputStream(""hashdata.ser"");
+    ObjectInputStream ois = new ObjectInputStream(fis);
+    Hashtable<Integer, String> ht_in =
+        (Hashtable<Integer, String>)(ois.readObject());
+    ois.close();
+ 
+    if (ht_in.contains(""Value""))
+      // Check whether the object actually exists in the Hashtable
+      System.out.println(""Value was found in deserialized object."");
+ 
+    if (ht_in.get(1) == null)  // Not printed
+      System.out.println(
+          ""Object was not found when retrieved using the key."");
+  }
+}"
+JAVA,"Methods (MET), 메서드",finalizer를 사용하지 마십시오.,"CWE-586, CWE-583, CWE-568","class MyFrame extends JFrame {
+  private byte[] buffer = new byte[16 * 1024 * 1024];
+  // Persists for at least two GC cycles
+}","class MyFrame {
+  private JFrame frame;
+  private byte[] buffer = new byte[16 * 1024 * 1024]; // Now decoupled
+}"
+JAVA,"Methods (MET), 메서드",finalizer를 사용하지 마십시오.,"CWE-586, CWE-583, CWE-568","class BaseClass {
+  protected void finalize() throws Throwable {
+    System.out.println(""Superclass finalize!"");
+    doLogic();
+  }
+ 
+  public void doLogic() throws Throwable {
+    System.out.println(""This is super-class!"");
+  }
+}
+ 
+class SubClass extends BaseClass {
+  private Date d; // Mutable instance field
+ 
+  protected SubClass() {
+    d = new Date();
+  }
+ 
+  protected void finalize() throws Throwable {
+    System.out.println(""Subclass finalize!"");
+    try {
+      //  Cleanup resources
+      d = null;
+    } finally {
+      super.finalize();  // Call BaseClass's finalizer
+    }
+  }
+ 
+  public void doLogic() throws Throwable {
+    // Any resource allocations made here will persist
+ 
+    // Inconsistent object state
+    System.out.println(
+        ""This is sub-class! The date object is: "" + d);
+    // 'd' is already null
+  }
+}
+ 
+public class BadUse {
+  public static void main(String[] args) {
+    try {
+      BaseClass bc = new SubClass();
+      // Artificially simulate finalization (do not do this)
+      System.runFinalizersOnExit(true);
+    } catch (Throwable t) {
+      // Handle error
+    }
+  }
+}","protected void finalize() throws Throwable {
+  try {
+    //...
+  } finally {
+    super.finalize();
+  }
+}"
+JAVA,"Methods (MET), 메서드",finalizer를 사용하지 마십시오.,"CWE-586, CWE-583, CWE-568","class BaseClass {
+  protected void finalize() throws Throwable {
+    System.out.println(""Superclass finalize!"");
+    doLogic();
+  }
+ 
+  public void doLogic() throws Throwable {
+    System.out.println(""This is super-class!"");
+  }
+}
+ 
+class SubClass extends BaseClass {
+  private Date d; // Mutable instance field
+ 
+  protected SubClass() {
+    d = new Date();
+  }
+ 
+  protected void finalize() throws Throwable {
+    System.out.println(""Subclass finalize!"");
+    try {
+      //  Cleanup resources
+      d = null;
+    } finally {
+      super.finalize();  // Call BaseClass's finalizer
+    }
+  }
+ 
+  public void doLogic() throws Throwable {
+    // Any resource allocations made here will persist
+ 
+    // Inconsistent object state
+    System.out.println(
+        ""This is sub-class! The date object is: "" + d);
+    // 'd' is already null
+  }
+}
+ 
+public class BadUse {
+  public static void main(String[] args) {
+    try {
+      BaseClass bc = new SubClass();
+      // Artificially simulate finalization (do not do this)
+      System.runFinalizersOnExit(true);
+    } catch (Throwable t) {
+      // Handle error
+    }
+  }
+}","public class Foo {
+  // The finalizeGuardian object finalizes the outer Foo object
+  private final Object finalizerGuardian = new Object() {
+    protected void finalize() throws Throwable {
+      // Finalize outer Foo object
+    }
+  };
+  //...
+}"
+JAVA,예외적인 동작 (ERR),확인된 예외를 억제하거나 무시하지 마세요.,"CWE-390, 조치 없이 오류 상태 감지","try {
+  //...
+} catch (IOException ioe) {
+  ioe.printStackTrace();
+}","boolean validFlag = false;
+do {
+  try {
+    // ...
+    // If requested file does not exist, throws FileNotFoundException
+    // If requested file exists, sets validFlag to true
+    validFlag = true;
+  } catch (FileNotFoundException e) {
+    // Ask the user for a different file name
+  }
+} while (validFlag != true);
+// Use the file"
+JAVA,예외적인 동작 (ERR),확인된 예외를 억제하거나 무시하지 마세요.,"CWE-390, 조치 없이 오류 상태 감지","class Foo implements Runnable {
+  public void run() {
+    try {
+      Thread.sleep(1000);
+    } catch (InterruptedException e) {
+      // Ignore
+    }
+  }
+}","class Foo implements Runnable {
+  public void run() {
+    try {
+      Thread.sleep(1000);
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt(); // Reset interrupted status
+    }
+  }
+}"
+JAVA,예외적인 동작 (ERR),예외로 인해 민감한 정보가 노출되는 것을 허용하지 마십시오.,"CWE-209 , 오류 메시지를 통한 정보 노출
+CWE-497 , 허가되지 않은 제어 영역에 대한 시스템 데이터 노출
+CWE-600 , 서블릿에서 발생하지 않은 예외","class ExceptionExample {
+  public static void main(String[] args) throws FileNotFoundException {
+    // Linux stores a user's home directory path in
+    // the environment variable $HOME, Windows in %APPDATA%
+    FileInputStream fis =
+        new FileInputStream(System.getenv(""APPDATA"") + args[0]); 
+  }
+}","class ExceptionExample {
+  public static void main(String[] args) {
+ 
+    File file = null;
+    try {
+      file = new File(System.getenv(""APPDATA"") +
+             args[0]).getCanonicalFile();
+      if (!file.getPath().startsWith(""c:\\homepath"")) {
+        System.out.println(""Invalid file"");
+        return;
+      }
+    } catch (IOException x) {
+      System.out.println(""Invalid file"");
+      return;
+    }
+ 
+    try {
+      FileInputStream fis = new FileInputStream(file);
+    } catch (FileNotFoundException x) {
+      System.out.println(""Invalid file"");
+      return;
+    }
+  }
+}"
+JAVA,예외적인 동작 (ERR),예외로 인해 민감한 정보가 노출되는 것을 허용하지 마십시오.,"CWE-209 , 오류 메시지를 통한 정보 노출
+CWE-497 , 허가되지 않은 제어 영역에 대한 시스템 데이터 노출
+CWE-601 , 서블릿에서 발생하지 않은 예외","try {
+  FileInputStream fis =
+      new FileInputStream(System.getenv(""APPDATA"") + args[0]);
+} catch (FileNotFoundException e) {
+  // Log the exception
+  throw new IOException(""Unable to retrieve file"", e);
+}","class ExceptionExample {
+  public static void main(String[] args) {
+    FileInputStream fis = null;
+    try {
+      switch(Integer.valueOf(args[0])) {
+        case 1:
+          fis = new FileInputStream(""c:\\homepath\\file1"");
+          break;
+        case 2:
+          fis = new FileInputStream(""c:\\homepath\\file2"");
+          break;
+        //...
+        default:
+          System.out.println(""Invalid option"");
+          break;
+      }     
+    } catch (Throwable t) {
+      MyExceptionReporter.report(t); // Sanitize
+    }
+  }
+}"
+JAVA,예외적인 동작 (ERR),데이터를 로깅할 때 예외가 발생하지 않도록 방지하십시오.,,"try {
+  // ...
+} catch (SecurityException se) {
+  System.err.println(se);
+  // Recover from exception
+}","try {
+  // ...
+} catch(SecurityException se) {
+  logger.log(Level.SEVERE, se);
+  // Recover from exception
+}"
+JAVA,예외적인 동작 (ERR),메서드 실패 시 이전 객체 상태 복원,"CWE-460, 던져진 예외에 대한 부적절한 정리","class Dimensions {
+  private int length;
+  private int width;
+  private int height;
+  static public final int PADDING = 2;
+  static public final int MAX_DIMENSION = 10;
+ 
+  public Dimensions(int length, int width, int height) {
+    this.length = length;
+    this.width = width;
+    this.height = height;
+  }
+ 
+  protected int getVolumePackage(int weight) {
+    length += PADDING;
+    width  += PADDING;
+    height += PADDING;
+    try {
+      if (length <= PADDING || width <= PADDING || height <= PADDING ||
+        length > MAX_DIMENSION + PADDING || width > MAX_DIMENSION + PADDING ||
+        height > MAX_DIMENSION + PADDING || weight <= 0 || weight > 20) {
+        throw new IllegalArgumentException();
+      }
+ 
+      int volume = length * width * height;
+      length -= PADDING; width -= PADDING; height -= PADDING; // Revert
+      return volume;
+    } catch (Throwable t) {
+      MyExceptionReporter mer = new MyExceptionReporter();
+      mer.report(t); // Sanitize
+      return -1; // Non-positive error code
+    }
+  }
+ 
+  public static void main(String[] args) {
+    Dimensions d = new Dimensions(8, 8, 8);
+    System.out.println(d.getVolumePackage(21)); // Prints -1 (error)
+    System.out.println(d.getVolumePackage(19));
+    // Prints 1728 (12x12x12) instead of 1000 (10x10x10)
+  }
+}","protected int getVolumePackage(int weight) {
+  length += PADDING;
+  width  += PADDING;
+  height += PADDING;
+  try {
+    if (length <= PADDING || width <= PADDING || height <= PADDING ||
+      length > MAX_DIMENSION + PADDING ||
+      width > MAX_DIMENSION + PADDING ||
+      height > MAX_DIMENSION + PADDING ||
+      weight <= 0 || weight > 20) {
+      throw new IllegalArgumentException();
+    }
+ 
+    int volume = length * width * height;
+    return volume;
+  } catch (Throwable t) {
+    MyExceptionReporter mer = new MyExceptionReporter();
+    mer.report(t); // Sanitize
+    return -1; // Non-positive error code
+  } finally {
+    // Revert
+    length -= PADDING; width -= PADDING; height -= PADDING;
+  }
+}"
+JAVA,예외적인 동작 (ERR),finally 블록에서 갑작스럽게 종료하지 마십시오.,"CWE-459, 불완전한 정리
+CWE-584, finally 블록 내에서 반환","class TryFinally {
+  private static boolean doLogic() {
+    try {
+      throw new IllegalStateException();
+    } finally {
+      System.out.println(""logic done"");
+      return true;
+    }
+  }
+}","class TryFinally {
+  private static boolean doLogic() {
+    try {
+      throw new IllegalStateException();
+    } finally {
+      System.out.println(""logic done"");
+    }
+    // Any return statements must go here;
+    // applicable only when exception is thrown conditionally
+  }
+}"
+JAVA,예외적인 동작 (ERR),finally 블록에서 검사된 예외가 탈출하지 않도록 하십시오.,"CWE-248, 포착되지 않은 예외
+CWE-460, 예외 발생 시 부적절한 정리
+CWE-584, finally 블록 내에서 반환
+CWE-705, 제어 흐름 범위 설정의 오류
+CWE-754, 비정상적이거나 예외적인 조건에 대한 부적절한 검사","public class Operation {
+  public static void doOperation(String some_file) {
+    // ... Code to check or set character encoding ...
+    try {
+      BufferedReader reader =
+          new BufferedReader(new FileReader(some_file));
+      try {
+        // Do operations
+      } finally {
+        reader.close();
+        // ... Other cleanup code ...
+      }
+    } catch (IOException x) {
+      // Forward to handler
+    }
+  }
+}","public class Operation {
+  public static void doOperation(String some_file) {
+    // ... Code to check or set character encoding ...
+    try {
+      BufferedReader reader =
+          new BufferedReader(new FileReader(some_file));
+      try {
+        // Do operations
+      } finally {
+        try {
+          reader.close();
+        } catch (IOException ie) {
+          // Forward to handler
+        }
+        // ... Other cleanup code ...
+      }
+    } catch (IOException x) {
+      // Forward to handler
+    }
+  }
+}"
+JAVA,예외적인 동작 (ERR),선언되지 않은 검사된 예외를 던지지 마십시오.,"CWE-703, 비정상적이거나 예외적인 조건에 대한 부적절한 검사 또는 처리
+CWE-248, 포착되지 않은 예외","public class NewInstance {
+  private static Throwable throwable;
+ 
+  private NewInstance() throws Throwable {
+    throw throwable;
+  }
+ 
+  public static synchronized void undeclaredThrow(Throwable throwable) {
+    // These exceptions should not be passed
+    if (throwable instanceof IllegalAccessException ||
+        throwable instanceof InstantiationException) {
+      // Unchecked, no declaration required
+      throw new IllegalArgumentException();
+    }
+ 
+    NewInstance.throwable = throwable;
+    try {
+      // Next line throws the Throwable argument passed in above,
+      // even though the throws clause of class.newInstance fails
+      // to declare that this may happen
+      NewInstance.class.newInstance();
+    } catch (InstantiationException e) { /* Unreachable */
+    } catch (IllegalAccessException e) { /* Unreachable */
+    } finally { // Avoid memory leak
+      NewInstance.throwable = null;
+    }
+  }
+}
+ 
+public class UndeclaredException {
+  public static void main(String[] args) {  
+    // No declared checked exceptions
+    NewInstance.undeclaredThrow(
+        new Exception(""Any checked exception""));
+  }
+}","public static synchronized void undeclaredThrow(Throwable throwable) {
+  // These exceptions should not be passed
+  if (throwable instanceof IllegalAccessException ||
+      throwable instanceof InstantiationException) {
+    // Unchecked, no declaration required
+    throw new IllegalArgumentException();
+  }
+ 
+  NewInstance.throwable = throwable;
+  try {
+    Constructor constructor =
+        NewInstance.class.getConstructor(new Class<?>[0]);
+    constructor.newInstance();
+  } catch (InstantiationException e) { /* Unreachable */
+  } catch (IllegalAccessException e) { /* Unreachable */
+  } catch (InvocationTargetException e) {
+    System.out.println(""Exception thrown: ""
+        + e.getCause().toString());
+  } finally { // Avoid memory leak
+    NewInstance.throwable = null;
+  }
+}"
+JAVA,예외적인 동작 (ERR),"RuntimeException, Exception, 또는 Throwable을 던지지 마십시오.","CWE-397, 일반 예외에 대한 throws 선언","boolean isCapitalized(String s) {
+  if (s == null) {
+    throw new RuntimeException(""Null String"");
+  }
+  if (s.equals("""")) {
+    return true;
+  }
+  String first = s.substring(0, 1);
+  String rest = s.substring(1);
+  return (first.equals(first.toUpperCase()) &&
+          rest.equals(rest.toLowerCase()));
+}","boolean isCapitalized(String s) {
+  if (s == null) {
+    throw new NullPointerException();
+  }
+  if (s.equals("""")) {
+    return true;
+  }
+  String first = s.substring(0, 1);
+  String rest = s.substring(1);
+  return (first.equals(first.toUpperCase()) &&
+          rest.equals(rest.toLowerCase()));
+}"
+JAVA,예외적인 동작 (ERR),"RuntimeException, Exception, 또는 Throwable을 던지지 마십시오.","CWE-398, 일반 예외에 대한 throws 선언","private void doSomething() throws Exception {
+  //...
+}","private void doSomething() throws IOException {
+  //...
+}"
+JAVA,예외적인 동작 (ERR),NullPointerException 또는 그 상위 예외를 잡지 마십시오.,,"boolean isName(String s) {
+  try {
+    String names[] = s.split("" "");
+ 
+    if (names.length != 2) {
+      return false;
+    }
+    return (isCapitalized(names[0]) && isCapitalized(names[1]));
+  } catch (NullPointerException e) {
+    return false;
+  }
+}","boolean isName(String s) {
+  if (s == null) {
+    return false;
+  }
+  String names[] = s.split("" "");
+  if (names.length != 2) {
+    return false;
+  }
+  return (isCapitalized(names[0]) && isCapitalized(names[1]));
+}"
+JAVA,예외적인 동작 (ERR),NullPointerException 또는 그 상위 예외를 잡지 마십시오.,,"boolean isName(String s) {
+  try {
+    String names[] = s.split("" "");
+ 
+    if (names.length != 2) {
+      return false;
+    }
+    return (isCapitalized(names[0]) && isCapitalized(names[2]));
+  } catch (NullPointerException e) {
+    return false;
+  }
+}","boolean isName(String s) /* Throws NullPointerException */ {
+  String names[] = s.split("" "");
+  if (names.length != 2) {
+    return false;
+  }
+  return (isCapitalized(names[0]) && isCapitalized(names[1]));
+}"
+JAVA,예외적인 동작 (ERR),NullPointerException 또는 그 상위 예외를 잡지 마십시오.,,"public interface Log {
+  void write(String messageToLog);
+}
+ 
+public class FileLog implements Log {
+  private final FileWriter out;
+ 
+  FileLog(String logFileName) throws IOException {
+    out = new FileWriter(logFileName, true);
+  }
+ 
+  public void write(String messageToLog) {
+    // Write message to file
+  }
+}
+ 
+public class ConsoleLog implements Log {
+  public void write(String messageToLog) {
+    System.out.println(messageToLog); // Write message to console
+  }
+}
+ 
+class Service {
+  private Log log;
+ 
+  Service() {
+    this.log = null; // No logger
+  }
+ 
+  Service(Log log) {
+    this.log = log; // Set the specified logger
+  }
+ 
+  public void handle() {
+    try {
+      log.write(""Request received and handled"");
+    } catch (NullPointerException npe) {
+      // Ignore
+    }
+  }
+ 
+  public static void main(String[] args) throws IOException {
+    Service s = new Service(new FileLog(""logfile.log""));
+    s.handle();
+ 
+    s = new Service(new ConsoleLog());
+    s.handle();
+  }
+}","public interface Log {
+ 
+  public static final Log NULL = new Log() {
+    public void write(String messageToLog) {
+      // Do nothing
+    }
+  };
+ 
+  void write(String messageToLog);
+}
+ 
+class Service {
+  private final Log log;
+ 
+  Service(){
+    this.log = Log.NULL;
+  }
+ 
+  // ...
+}"
+JAVA,예외적인 동작 (ERR),NullPointerException 또는 그 상위 예외를 잡지 마십시오.,,"public class DivideException {
+  public static void division(int totalSum, int totalNumber)
+    throws ArithmeticException, IOException  {
+    int average  = totalSum / totalNumber;
+    // Additional operations that may throw IOException...
+    System.out.println(""Average: "" + average);
+  }
+  public static void main(String[] args) {
+    try {
+      division(200, 5);
+      division(200, 0); // Divide by zero
+    } catch (Exception e) {
+      System.out.println(""Divide by zero exception : ""
+                         + e.getMessage());
+    }
+  }
+}","import java.io.IOException;
+ 
+public class DivideException {
+  public static void main(String[] args) {
+    try {
+      division(200, 5);
+      division(200, 0); // Divide by zero
+    } catch (ArithmeticException ae) {
+      // DivideByZeroException extends Exception so is checked
+      throw new DivideByZeroException(); 
+    } catch (IOException ex) {
+      ExceptionReporter.report(ex);
+    }
+  }
+ 
+  public static void division(int totalSum, int totalNumber)
+                              throws ArithmeticException, IOException  {
+    int average  = totalSum / totalNumber;
+    // Additional operations that may throw IOException...
+    System.out.println(""Average: ""+ average);
+  }
+}"
+JAVA,예외적인 동작 (ERR),신뢰할 수 없는 코드가 JVM을 종료하도록 허용하지 마십시오.,"CWE-382, J2EE Bad Practices: Use of System.exit()","public class InterceptExit {
+  public static void main(String[] args) {
+    // ...
+    System.exit(1);  // Abrupt exit
+    System.out.println(""This never executes"");
+  }
+}","class PasswordSecurityManager extends SecurityManager {
+  private boolean isExitAllowedFlag;
+   
+  public PasswordSecurityManager(){
+    super();
+    isExitAllowedFlag = false; 
+  }
+  
+  public boolean isExitAllowed(){
+    return isExitAllowedFlag;   
+  }
+  
+  @Override
+  public void checkExit(int status) {
+    if (!isExitAllowed()) {
+      throw new SecurityException();
+    }
+    super.checkExit(status);
+  }
+  
+  public void setExitAllowed(boolean f) {
+    isExitAllowedFlag = f;  
+  }
+}
+ 
+public class InterceptExit {
+  public static void main(String[] args) {
+    PasswordSecurityManager secManager =
+        new PasswordSecurityManager();
+    System.setSecurityManager(secManager);
+    try {
+      // ...
+      System.exit(1);  // Abrupt exit call
+    } catch (Throwable x) {
+      if (x instanceof SecurityException) {
+        System.out.println(""Intercepted System.exit()"");
+        // Log exception
+      } else {
+        // Forward to exception handler
+      }
+    }
+ 
+    // ...
+    secManager.setExitAllowed(true);  // Permit exit
+    // System.exit() will work subsequently
+    // ...
+  }
+}"
+JAVA,가시성과 원자성 (VNA),공유된 원시 변수에 접근할 때 가시성을 보장하십시오.,"CWE-413, 부적절한 자원 잠금
+CWE-567, 다중 스레드 환경에서 공유 데이터에 대한 비동기화된 접근
+CWE-667, 부적절한 잠금","final class ControlledStop implements Runnable {
+  private boolean done = false;
+  
+  @Override public void run() {
+    while (!done) {
+      try {
+        // ...
+        Thread.currentThread().sleep(1000); // Do something
+      } catch(InterruptedException ie) {
+        Thread.currentThread().interrupt(); // Reset interrupted status
+      }
+    }   
+  }
+ 
+  public void shutdown() {
+    done = true;
+  }
+}","final class ControlledStop implements Runnable {
+  private volatile boolean done = false;
+  
+  @Override public void run() {
+    while (!done) {
+      try {
+        // ...
+        Thread.currentThread().sleep(1000); // Do something
+      } catch(InterruptedException ie) {
+        Thread.currentThread().interrupt(); // Reset interrupted status
+      }
+    }   
+  }
+ 
+  public void shutdown() {
+    done = true;
+  }
+}"
+JAVA,가시성과 원자성 (VNA),공유된 원시 변수에 접근할 때 가시성을 보장하십시오.,"CWE-413, 부적절한 자원 잠금
+CWE-567, 다중 스레드 환경에서 공유 데이터에 대한 비동기화된 접근
+CWE-667, 부적절한 잠금","final class ControlledStop implements Runnable {
+  private boolean done = false;
+  
+  @Override public void run() {
+    while (!done) {
+      try {
+        // ...
+        Thread.currentThread().sleep(1001); // Do something
+      } catch(InterruptedException ie) {
+        Thread.currentThread().interrupt(); // Reset interrupted status
+      }
+    }   
+  }
+ 
+  public void shutdown() {
+    done = true;
+  }
+}","final class ControlledStop implements Runnable {
+  private final AtomicBoolean done = new AtomicBoolean(false);
+  
+  @Override public void run() {
+    while (!done.get()) {
+      try {
+        // ...
+        Thread.currentThread().sleep(1000); // Do something
+      } catch(InterruptedException ie) {
+        Thread.currentThread().interrupt(); // Reset interrupted status
+      }
+    }   
+  }
+ 
+  public void shutdown() {
+    done.set(true);
+  }
+}"
+JAVA,가시성과 원자성 (VNA),공유된 원시 변수에 접근할 때 가시성을 보장하십시오.,"CWE-413, 부적절한 자원 잠금
+CWE-567, 다중 스레드 환경에서 공유 데이터에 대한 비동기화된 접근
+CWE-667, 부적절한 잠금","final class ControlledStop implements Runnable {
+  private boolean done = false;
+  
+  @Override public void run() {
+    while (!done) {
+      try {
+        // ...
+        Thread.currentThread().sleep(1002); // Do something
+      } catch(InterruptedException ie) {
+        Thread.currentThread().interrupt(); // Reset interrupted status
+      }
+    }   
+  }
+ 
+  public void shutdown() {
+    done = true;
+  }
+}","final class ControlledStop implements Runnable {
+  private boolean done = false;
+  
+  @Override public void run() {
+    while (!isDone()) {
+      try {
+        // ...
+        Thread.currentThread().sleep(1000); // Do something
+      } catch(InterruptedException ie) {
+        Thread.currentThread().interrupt(); // Reset interrupted status
+      }
+    }   
+  }
+ 
+  public synchronized boolean isDone() {
+    return done;
+  }
+ 
+  public synchronized void shutdown() {
+    done = true;
+  }
+}"
+JAVA,가시성과 원자성 (VNA),불변 객체에 대한 공유 참조의 가시성을 보장하십시오.,,"// Immutable Helper
+public final class Helper {
+  private final int n;
+ 
+  public Helper(int n) {
+    this.n = n;
+  }
+  // ...
+}
+
+final class Foo {
+  private Helper helper;
+ 
+  public Helper getHelper() {
+    return helper;
+  }
+ 
+  public void setHelper(int num) {
+    helper = new Helper(num);
+  }
+}","final class Foo {
+  private Helper helper;
+ 
+  public synchronized Helper getHelper() {
+    return helper;
+  }
+ 
+  public synchronized void setHelper(int num) {
+    helper = new Helper(num);
+  }
+}"
+JAVA,가시성과 원자성 (VNA),불변 객체에 대한 공유 참조의 가시성을 보장하십시오.,,"// Immutable Helper
+public final class Helper {
+  private final int n;
+ 
+  public Helper(int n) {
+    this.n = n;
+  }
+  // ...
+}
+
+final class Foo {
+  private Helper helper;
+ 
+  public Helper getHelper() {
+    return helper;
+  }
+ 
+  public void setHelper(int num) {
+    helper = new Helper(num);
+  }
+}","final class Foo {
+  private volatile Helper helper;
+ 
+  public Helper getHelper() {
+    return helper;
+  }
+ 
+  public void setHelper(int num) {
+    helper = new Helper(num);
+  }
+}"
+JAVA,가시성과 원자성 (VNA),불변 객체에 대한 공유 참조의 가시성을 보장하십시오.,,"// Immutable Helper
+public final class Helper {
+  private final int n;
+ 
+  public Helper(int n) {
+    this.n = n;
+  }
+  // ...
+}
+
+final class Foo {
+  private Helper helper;
+ 
+  public Helper getHelper() {
+    return helper;
+  }
+ 
+  public void setHelper(int num) {
+    helper = new Helper(num);
+  }
+}","final class Foo {
+  private final AtomicReference<Helper> helperRef =
+      new AtomicReference<Helper>();
+ 
+  public Helper getHelper() {
+    return helperRef.get();
+  }
+ 
+  public void setHelper(int num) {
+    helperRef.set(new Helper(num));
+  }
+}"
+JAVA,가시성과 원자성 (VNA),공유 변수에 대한 복합 연산이 원자적으로 수행되도록 보장하십시오.,"CWE-366, 스레드 내에서의 경쟁 조건
+CWE-413, 부적절한 자원 잠금
+CWE-567, 다중 스레드 환경에서 공유 데이터에 대한 비동기화된 접근
+CWE-667, 부적절한 잠금","final class Flag {
+  private boolean flag = true;
+ 
+  public void toggle() {  // Unsafe
+    flag = !flag;
+  }
+ 
+  public boolean getFlag() { // Unsafe
+    return flag;
+  }
+}","final class Flag {
+  private boolean flag = true;
+
+  public synchronized void toggle() {
+    flag = !flag;
+  }
+
+  public synchronized boolean getFlag() {
+    return flag;
+  }
+}"
+JAVA,가시성과 원자성 (VNA),공유 변수에 대한 복합 연산이 원자적으로 수행되도록 보장하십시오.,"CWE-366, 스레드 내에서의 경쟁 조건
+CWE-413, 부적절한 자원 잠금
+CWE-567, 다중 스레드 환경에서 공유 데이터에 대한 비동기화된 접근
+CWE-667, 부적절한 잠금","final class Flag {
+  private boolean flag = true;
+
+  public void toggle() {  // 안전하지 않음
+    flag ^= true;  // flag = !flag;와 동일
+  }
+
+  public boolean getFlag() { // 안전하지 않음
+    return flag;
+  }
+}","final class Flag {
+  private boolean flag = true;
+
+  public synchronized void toggle() {
+    flag ^= true;  // flag = !flag;와 동일
+  }
+
+  public synchronized boolean getFlag() {
+    return flag;
+  }
+}"
+JAVA,가시성과 원자성 (VNA),공유 변수에 대한 복합 연산이 원자적으로 수행되도록 보장하십시오.,"CWE-366, 스레드 내에서의 경쟁 조건
+CWE-413, 부적절한 자원 잠금
+CWE-567, 다중 스레드 환경에서 공유 데이터에 대한 비동기화된 접근
+CWE-667, 부적절한 잠금","final class Flag {
+  private volatile boolean flag = true;
+
+  public void toggle() {  // 안전하지 않음
+    flag ^= true;
+  }
+
+  public boolean getFlag() { // 안전함
+    return flag;
+  }
+}","final class Flag {
+  private volatile boolean flag = true;
+
+  public synchronized void toggle() {
+    flag ^= true;
+  }
+
+  public boolean getFlag() {
+    return flag;
+  }
+}"
+JAVA,가시성과 원자성 (VNA),독립적으로 원자적인 메서드에 대한 호출 그룹이 원자적이라고 가정하지 마십시오.,"CWE-362, 적절하지 않은 동기화로 공유 자원을 사용하는 동시 실행 (""경쟁 조건"")
+CWE-366, 스레드 내에서의 경쟁 조건
+CWE-662, 부적절한 동기화","final class Adder {
+  private final AtomicReference<BigInteger> first;
+  private final AtomicReference<BigInteger> second;
+ 
+  public Adder(BigInteger f, BigInteger s) {
+    first  = new AtomicReference<BigInteger>(f);
+    second = new AtomicReference<BigInteger>(s);
+  }
+ 
+  public void update(BigInteger f, BigInteger s) { // Unsafe
+    first.set(f);
+    second.set(s);
+  }
+ 
+  public BigInteger add() { // Unsafe
+    return first.get().add(second.get());
+  }
+}","final class Adder {
+  // ...
+  private final AtomicReference<BigInteger> first;
+  private final AtomicReference<BigInteger> second;
+ 
+  public Adder(BigInteger f, BigInteger s) {
+    first  = new AtomicReference<BigInteger>(f);
+    second = new AtomicReference<BigInteger>(s);
+  }
+ 
+ 
+ 
+  public synchronized void update(BigInteger f, BigInteger s){
+    first.set(f);
+    second.set(s);
+  }
+ 
+  public synchronized BigInteger add() {
+    return first.get().add(second.get());
+  }
+}"
+JAVA,가시성과 원자성 (VNA),독립적으로 원자적인 메서드에 대한 호출 그룹이 원자적이라고 가정하지 마십시오.,"CWE-362, 적절하지 않은 동기화로 공유 자원을 사용하는 동시 실행 (""경쟁 조건"")
+CWE-366, 스레드 내에서의 경쟁 조건
+CWE-662, 부적절한 동기화","final class IPHolder {
+  private final List<InetAddress> ips =
+      Collections.synchronizedList(new ArrayList<InetAddress>());
+ 
+  public void addAndPrintIPAddresses(InetAddress address) {
+    ips.add(address);
+    InetAddress[] addressCopy =
+        (InetAddress[]) ips.toArray(new InetAddress[0]);
+    // Iterate through array addressCopy ...
+  }
+}","final class IPHolder {
+  private final List<InetAddress> ips =
+      Collections.synchronizedList(new ArrayList<InetAddress>());
+ 
+  public void addAndPrintIPAddresses(InetAddress address) {
+    synchronized (ips) {
+      ips.add(address);
+      InetAddress[] addressCopy =
+          (InetAddress[]) ips.toArray(new InetAddress[0]);
+      // Iterate through array addressCopy ...
+    }
+  }
+}"
+JAVA,가시성과 원자성 (VNA),독립적으로 원자적인 메서드에 대한 호출 그룹이 원자적이라고 가정하지 마십시오.,"CWE-362, 적절하지 않은 동기화로 공유 자원을 사용하는 동시 실행 (""경쟁 조건"")
+CWE-366, 스레드 내에서의 경쟁 조건
+CWE-662, 부적절한 동기화","final class KeyedCounter {
+  private final Map<String, Integer> map =
+      Collections.synchronizedMap(new HashMap<String, Integer>());
+ 
+  public void increment(String key) {
+    Integer old = map.get(key);
+    int oldValue = (old == null) ? 0 : old.intValue();
+    if (oldValue == Integer.MAX_VALUE) {
+      throw new ArithmeticException(""Out of range"");
+    }
+    map.put( key, oldValue + 1);
+  }
+ 
+  public Integer getCount(String key) {
+    return map.get(key);
+  }
+}","final class KeyedCounter {
+  private final Map<String, Integer> map =
+      new HashMap<String, Integer>();
+  private final Object lock = new Object();
+ 
+  public void increment(String key) {
+    synchronized (lock) {
+      Integer old = map.get(key);
+      int oldValue = (old == null) ? 0 : old.intValue();
+      if (oldValue == Integer.MAX_VALUE) {
+        throw new ArithmeticException(""Out of range"");
+      }
+      map.put(key, oldValue + 1);
+    }
+  }
+ 
+  public Integer getCount(String key) {
+    synchronized (lock) {
+      return map.get(key);
+    }
+  }
+}"
+JAVA,가시성과 원자성 (VNA),체인된 메서드 호출이 원자적으로 수행되도록 보장하십시오.,,"final class USCurrency {
+  // Change requested, denomination (optional fields)
+  private int quarters = 0;
+  private int dimes = 0;
+  private int nickels = 0;
+  private int pennies = 0;
+ 
+  public USCurrency() {}
+ 
+  // Setter methods
+  public USCurrency setQuarters(int quantity) {
+    quarters = quantity;
+    return this;
+  }
+  public USCurrency setDimes(int quantity) {
+    dimes = quantity;
+    return this;
+  }
+  public USCurrency setNickels(int quantity) {
+    nickels = quantity;
+    return this;
+  }
+  public USCurrency setPennies(int quantity) {
+    pennies = quantity;
+    return this;
+  }
+}
+ 
+// Client code:
+class ExampleClientCode {
+ 
+  private final USCurrency currency = new USCurrency();
+  // ...
+ 
+  public ExampleClientCode() {
+ 
+    Thread t1 = new Thread(new Runnable() {
+        @Override public void run() {
+          currency.setQuarters(1).setDimes(1);
+        }
+    });
+    t1.start();
+ 
+    Thread t2 = new Thread(new Runnable() {
+        @Override public void run() {
+          currency.setQuarters(2).setDimes(2);
+        }
+    });
+    t2.start();
+ 
+    //...
+  }
+}","final class USCurrency {
+  private final int quarters;
+  private final int dimes;
+  private final int nickels;
+  private final int pennies;
+ 
+  public USCurrency(Builder builder) {
+    this.quarters = builder.quarters;
+    this.dimes = builder.dimes;
+    this.nickels = builder.nickels;
+    this.pennies = builder.pennies;
+  }
+ 
+  // Static class member
+  public static class Builder {
+    private int quarters = 0;
+    private int dimes = 0;
+    private int nickels = 0;
+    private int pennies = 0;
+ 
+    public static Builder newInstance() {
+      return new Builder();
+    }
+ 
+    private Builder() {}
+ 
+    // Setter methods
+    public Builder setQuarters(int quantity) {
+      this.quarters = quantity;
+      return this;
+    }
+    public Builder setDimes(int quantity) {
+      this.dimes = quantity;
+      return this;
+    }
+    public Builder setNickels(int quantity) {
+      this.nickels = quantity;
+      return this;
+    }
+    public Builder setPennies(int quantity) {
+      this.pennies = quantity;
+      return this;
+    }
+ 
+    public USCurrency build() {
+      return new USCurrency(this);
+    }
+  }
+}
+ 
+// Client code:
+class ExampleClientCode  {
+ 
+  private volatile USCurrency currency;
+  // ...
+ 
+  public ExampleClientCode() {
+ 
+    Thread t1 = new Thread(new Runnable() {
+        @Override public void run() {
+          currency = USCurrency.Builder.newInstance().
+                         setQuarters(1).setDimes(1).build();
+        }
+    });
+    t1.start();
+ 
+    Thread t2 = new Thread(new Runnable() {
+        @Override public void run() {
+          currency = USCurrency.Builder.newInstance().
+                         setQuarters(2).setDimes(2).build();
+        }
+    });
+    t2.start();
+ 
+    //...
+  }
+}"
+JAVA,가시성과 원자성 (VNA),64비트 값을 읽고 쓸 때 원자성을 보장하십시오.,"CWE-667, 부적절한 잠금","class LongContainer {
+  private long i = 0;
+ 
+  void assignValue(long j) {
+    i = j;
+  }
+ 
+  void printLong() {
+    System.out.println(""i = "" + i);
+  }
+}","class LongContainer {
+  private volatile long i = 0;
+ 
+  void assignValue(long j) {
+    i = j;
+  }
+ 
+  void printLong() {
+    System.out.println(""i = "" + i);
+  }
+}"
+JAVA,Locking (LCK),private final 잠금 객체를 사용하여 신뢰할 수 없는 코드와 상호 작용할 수 있는 클래스를 동기화하십시오.,"CWE-412, 외부에서 접근 가능한 잠금의 제한 없음
+CWE-413, 부적절한 자원 잠금","public class SomeObject {
+  public final Object lock = new Object();
+ 
+  public void changeValue() {
+    synchronized (lock) {
+      // ...
+    }
+  }
+}","public class SomeObject {
+  private final Object lock = new Object(); // private final lock object
+ 
+  public void changeValue() {
+    synchronized (lock) { // Locks on the private Object
+      // ...
+    }
+  }
+}"
+JAVA,Locking (LCK),private final 잠금 객체를 사용하여 신뢰할 수 없는 코드와 상호 작용할 수 있는 클래스를 동기화하십시오.,"CWE-412, 외부에서 접근 가능한 잠금의 제한 없음
+CWE-413, 부적절한 자원 잠금","public class SomeObject {
+  //changeValue locks on the class object's monitor
+  public static synchronized void changeValue() {
+    // ...
+  }
+}
+ 
+// Untrusted code
+synchronized (SomeObject.class) {
+  while (true) {
+    Thread.sleep(Integer.MAX_VALUE); // Indefinitely delay someObject
+  }
+}","public class SomeObject {
+  private static final Object lock = new Object();
+ 
+  public static void changeValue() {
+    synchronized (lock) { // Locks on the private Object
+      // ...
+    }
+  }
+}"
+JAVA,Locking (LCK),재사용될 수 있는 객체에서 동기화하지 마십시오.,,"private final Boolean initialized = Boolean.FALSE;
+
+public void doSomething() {
+  synchronized (initialized) {
+    // ...
+  }
+}","private final Object lock = new Object();
+
+public void doSomething() {
+  synchronized (lock) {
+    // ...
+  }
+}"
+JAVA,Locking (LCK),재사용될 수 있는 객체에서 동기화하지 마십시오.,,"private int count = 0;
+private final Integer Lock = count; // 박싱된 프리미티브 Lock이 공유됨
+
+public void doSomething() {
+  synchronized (Lock) {
+    count++;
+    // ...
+  }
+}","private int count = 0;
+private final Object lock = new Object();
+
+public void doSomething() {
+  synchronized (lock) {
+    count++;
+    // ...
+  }
+}"
+JAVA,Locking (LCK),재사용될 수 있는 객체에서 동기화하지 마십시오.,,"private final String lock = new String(""LOCK"").intern();
+
+public void doSomething() {
+  synchronized (lock) {
+    // ...
+  }
+}","private final Object lock = new Object();
+
+public void doSomething() {
+  synchronized (lock) {
+    // ...
+  }
+}"
+JAVA,Locking (LCK),getClass()가 반환하는 클래스 객체에 동기화하지 마십시오.,,"class Base {
+  static DateFormat format =
+      DateFormat.getDateInstance(DateFormat.MEDIUM);
+ 
+  public Date parse(String str) throws ParseException {
+    synchronized (getClass()) {
+      return format.parse(str);
+    }
+  }
+}
+ 
+class Derived extends Base {
+  public Date doSomethingAndParse(String str) throws ParseException {
+    synchronized (Base.class) {
+      // ...
+      return format.parse(str);
+    }
+  }
+}","class Base {
+  static DateFormat format = DateFormat.getDateInstance(DateFormat.MEDIUM);
+
+  public Date parse(String str) throws ParseException {
+    synchronized (Base.class) {
+      return format.parse(str);
+    }
+  }
+}"
+JAVA,Locking (LCK),고수준 동시성 객체의 내재적 잠금에 동기화하지 마십시오.,,"private final Lock lock = new ReentrantLock();
+ 
+public void doSomething() {
+  synchronized(lock) {
+    // ...
+  }
+}","private final Lock lock = new ReentrantLock();
+ 
+public void doSomething() {
+  lock.lock();
+  try {
+    // ...
+  } finally {
+    lock.unlock();
+  }
+}"
+JAVA,Locking (LCK),"백업 컬렉션이 접근 가능한 경우, 컬렉션 뷰에 동기화하지 마십시오.",,"private final Map<Integer, String> mapView =
+    Collections.synchronizedMap(new HashMap<Integer, String>());
+private final Set<Integer> setView = mapView.keySet();
+ 
+public Map<Integer, String> getMap() {
+  return mapView;
+}
+ 
+public void doSomething() {
+  synchronized (setView) {  // Incorrectly synchronizes on setView
+    for (Integer k : setView) {
+      // ...
+    }
+  }
+}","private final Map<Integer, String> mapView =
+    Collections.synchronizedMap(new HashMap<Integer, String>());
+private final Set<Integer> setView = mapView.keySet();
+ 
+public Map<Integer, String> getMap() {
+  return mapView;
+}
+ 
+public void doSomething() {
+  synchronized (mapView) {  // Synchronize on map, rather than set
+    for (Integer k : setView) {
+      // ...
+    }
+  }
+}"
+JAVA,Locking (LCK),신뢰할 수 없는 코드에 의해 수정될 수 있는 정적 필드에 대한 접근을 동기화하십시오.,"CWE-820, 동기화 누락","/* This class is not thread-safe */
+public final class CountHits {
+  private static int counter;
+ 
+  public void incrementCounter() {
+    counter++;
+  }
+}","/* This class is thread-safe */
+public final class CountHits {
+  private static int counter;
+  private static final Object lock = new Object();
+ 
+  public void incrementCounter() {
+    synchronized (lock) {
+      counter++;
+    }
+  }
+}"
+JAVA,Locking (LCK),공유된 정적 데이터를 보호하기 위해 인스턴스 잠금을 사용하지 마십시오.,"CWE-667, 부적절한 잠금","public final class CountBoxes implements Runnable {
+  private static volatile int counter;
+  // ...
+  private final Object lock = new Object();
+
+  @Override
+  public void run() {
+    synchronized (lock) {
+      counter++;
+      // ...
+    }
+  }
+
+  public static void main(String[] args) {
+    for (int i = 0; i < 2; i++) {
+      new Thread(new CountBoxes()).start();
+    }
+  }
+}","public class CountBoxes implements Runnable {
+  private static int counter;
+  // ...
+  private static final Object lock = new Object();
+
+  public void run() {
+    synchronized (lock) {
+      counter++;
+      // ...
+    }
+  }
+  // ...
+}"
+JAVA,Locking (LCK),동일한 순서로 잠금을 요청하고 해제하여 교착 상태를 피하십시오.,"CWE-833, Deadlock","final class BankAccount {
+  private double balanceAmount;  // 총 계좌 잔액
+
+  BankAccount(double balance) {
+    this.balanceAmount = balance;
+  }
+
+  // 이 객체 인스턴스에서 주어진 BankAccount 인스턴스로 금액을 입금
+  private void depositAmount(BankAccount ba, double amount) {
+    synchronized (this) {
+      synchronized (ba) {
+        if (amount > balanceAmount) {
+          throw new IllegalArgumentException(""이체를 완료할 수 없습니다"");
+        }
+        ba.balanceAmount += amount;
+        this.balanceAmount -= amount;
+      }
+    }
+  }
+
+  public static void initiateTransfer(final BankAccount first,
+    final BankAccount second, final double amount) {
+
+    Thread transfer = new Thread(new Runnable() {
+        public void run() {
+          first.depositAmount(second, amount);
+        }
+    });
+    transfer.start();
+  }
+}","final class BankAccount implements Comparable<BankAccount> {
+  private double balanceAmount;  // 총 계좌 잔액
+  private final long id;  // 각 BankAccount에 대한 고유 ID
+  private static final AtomicLong nextID = new AtomicLong(0);  // 다음 사용 가능한 ID
+
+  BankAccount(double balance) {
+    this.balanceAmount = balance;
+    this.id = nextID.getAndIncrement();
+  }
+
+  @Override
+  public int compareTo(BankAccount ba) {
+    return Long.compare(this.id, ba.id);
+  }
+
+  // 이 객체 인스턴스에서 주어진 BankAccount 인스턴스로 금액을 입금
+  public void depositAmount(BankAccount ba, double amount) {
+    BankAccount former, latter;
+    if (compareTo(ba) < 0) {
+      former = this;
+      latter = ba;
+    } else {
+      former = ba;
+      latter = this;
+    }
+    synchronized (former) {
+      synchronized (latter) {
+        if (amount > balanceAmount) {
+          throw new IllegalArgumentException(""이체를 완료할 수 없습니다"");
+        }
+        ba.balanceAmount += amount;
+        this.balanceAmount -= amount;
+      }
+    }
+  }
+
+  public static void initiateTransfer(final BankAccount first,
+    final BankAccount second, final double amount) {
+
+    Thread transfer = new Thread(new Runnable() {
+        public void run() {
+          first.depositAmount(second, amount);
+        }
+    });
+    transfer.start();
+  }
+}"
+JAVA,Locking (LCK),예외 상황에서 보유 중인 락을 해제하라,"CWE-834, Deadlock","public final class Client {
+  private final Lock lock = new ReentrantLock();
+
+  public void doSomething(File file) {
+    InputStream in = null;
+    try {
+      in = new FileInputStream(file);
+      lock.lock();
+      // 파일에 대한 작업 수행
+    } catch (FileNotFoundException fnf) {
+      // 예외 처리
+    } finally {
+      lock.unlock();
+      if (in != null) {
+        try {
+          in.close();
+        } catch (IOException e) {
+          // 예외 처리
+        }
+      }
+    }
+  }
+}","public final class Client {
+  private final Lock lock = new ReentrantLock();
+
+  public void doSomething(File file) {
+    InputStream in = null;
+    lock.lock();
+    try {
+      in = new FileInputStream(file);
+      // 파일에 대한 작업 수행
+    } catch (FileNotFoundException fnf) {
+      // 예외 처리
+    } finally {
+      if (in != null) {
+        try {
+          in.close();
+        } catch (IOException e) {
+          // 예외 처리
+        }
+      }
+      lock.unlock();
+    }
+  }
+}"
+JAVA,Locking (LCK),잠금을 보유한 상태에서 차단될 수 있는 작업을 수행하지 마십시오.,,"public synchronized void doSomething(long time)
+                         throws InterruptedException {
+  // ...
+  Thread.sleep(time);
+}","public synchronized void doSomething(long timeout)
+                                     throws InterruptedException {
+// ...
+  while (<condition does not hold>) {
+    wait(timeout); // Immediately releases the current monitor
+  }
+}"
+JAVA,Locking (LCK),잠금을 보유한 상태에서 차단될 수 있는 작업을 수행하지 마십시오.,,"// Class Page is defined separately.
+// It stores and returns the Page name via getName()
+Page[] pageBuff = new Page[MAX_PAGE_SIZE];
+ 
+public synchronized boolean sendPage(Socket socket, String pageName)
+                                     throws IOException {
+  // Get the output stream to write the Page to
+  ObjectOutputStream out
+      = new ObjectOutputStream(socket.getOutputStream());
+ 
+  // Find the Page requested by the client
+  // (this operation requires synchronization)
+  Page targetPage = null;
+  for (Page p : pageBuff) {
+    if (p.getName().compareTo(pageName) == 0) {
+      targetPage = p;
+    }
+  }
+ 
+  // Requested Page does not exist
+  if (targetPage == null) {
+    return false;
+  }
+ 
+  // Send the Page to the client
+  // (does not require any synchronization)
+  out.writeObject(targetPage);
+ 
+  out.flush();
+  out.close();
+  return true;
+}","// No synchronization
+public boolean sendPage(Socket socket, String pageName) {
+  Page targetPage = getPage(pageName);
+ 
+  if (targetPage == null){
+    return false;
+  }
+  return deliverPage(socket, targetPage);
+}
+ 
+// Requires synchronization
+private synchronized Page getPage(String pageName) {
+  Page targetPage = null;
+ 
+  for (Page p : pageBuff) {
+    if (p.getName().equals(pageName)) {
+      targetPage = p;
+    }
+  }
+  return targetPage;
+}
+ 
+// Return false if an error occurs, true if successful
+public boolean deliverPage(Socket socket, Page page) {
+  ObjectOutputStream out = null;
+  boolean result = true;
+  try {
+    // Get the output stream to write the Page to
+    out = new ObjectOutputStream(socket.getOutputStream());
+ 
+    // Send the page to the client
+    out.writeObject(page);out.flush();
+  } catch (IOException io) {
+    result = false;
+  } finally {
+    if (out != null) {
+      try {
+        out.close();
+      } catch (IOException e) {
+        result = false;
+      }
+    }
+  }
+  return result;
+}"
+JAVA,Locking (LCK),올바른 형태의 이중 검사 잠금 패턴을 사용하라,"CWE-609, Double-checked Locking","final class Foo {
+  private Helper helper = null;
+
+  public Helper getHelper() {
+    if (helper == null) {
+      synchronized (this) {
+        if (helper == null) {
+          helper = new Helper();
+        }
+      }
+    }
+    return helper;
+  }
+  // 기타 메서드 및 멤버...
+}","final class Foo {
+  private volatile Helper helper = null;
+
+  public Helper getHelper() {
+    if (helper == null) {
+      synchronized (this) {
+        if (helper == null) {
+          helper = new Helper();
+        }
+      }
+    }
+    return helper;
+  }
+  // 기타 메서드 및 멤버...
+}"
+JAVA,Locking (LCK),일관된 락 전략을 명시하지 않은 클래스 사용 시 클라이언트 측 락을 피하라,,"final class Book {
+  private final String title;
+  private Calendar dateIssued;
+  private Calendar dateDue;
+
+  public synchronized void issue(int days) {
+    dateIssued = Calendar.getInstance();
+    dateDue = Calendar.getInstance();
+    dateDue.add(Calendar.DATE, days);
+  }
+
+  public synchronized Calendar getDueDate() {
+    return dateDue;
+  }
+}
+
+public class BookWrapper {
+  private final Book book;
+
+  public BookWrapper(Book book) {
+    this.book = book;
+  }
+
+  public void renew() {
+    synchronized (book) {
+      if (book.getDueDate().before(Calendar.getInstance())) {
+        throw new IllegalStateException(""Book overdue"");
+      } else {
+        book.issue(14);
+      }
+    }
+  }
+}","final class Book {
+  private final String title;
+  private Calendar dateIssued;
+  private Calendar dateDue;
+  private final Object lock = new Object();
+
+  public void issue(int days) {
+    synchronized (lock) {
+      dateIssued = Calendar.getInstance();
+      dateDue = Calendar.getInstance();
+      dateDue.add(Calendar.DATE, days);
+    }
+  }
+
+  public Calendar getDueDate() {
+    synchronized (lock) {
+      return dateDue;
+    }
+  }
+
+  public void renew() {
+    synchronized (lock) {
+      if (getDueDate().before(Calendar.getInstance())) {
+        throw new IllegalStateException(""Book overdue"");
+      } else {
+        issue(14);
+      }
+    }
+  }
+}"
+JAVA,Thread APIs (THI),Do not invoke Thread.run(),"CWE-572, Call to Thread run() instead of start()","public final class Foo implements Runnable {
+  @Override
+  public void run() {
+    // ...
+  }
+
+  public static void main(String[] args) {
+    Foo foo = new Foo();
+    new Thread(foo).run(); // 잘못된 호출
+  }
+}","public final class Foo implements Runnable {
+  @Override
+  public void run() {
+    // ...
+  }
+
+  public static void main(String[] args) {
+    Foo foo = new Foo();
+    new Thread(foo).start(); // 올바른 호출
+  }
+}"
+JAVA,Thread APIs (THI),Do not invoke ThreadGroup methods,,"final class HandleRequest implements Runnable {
+  public void run() {
+    // Do something
+  }
+}
+ 
+public final class NetworkHandler implements Runnable {
+  private static ThreadGroup tg = new ThreadGroup(""Chief"");
+ 
+  @Override public void run() {
+    new Thread(tg, new HandleRequest(), ""thread1"").start();
+    new Thread(tg, new HandleRequest(), ""thread2"").start();
+    new Thread(tg, new HandleRequest(), ""thread3"").start();
+  }
+ 
+  public static void printActiveCount(int point) {
+    System.out.println(""Active Threads in Thread Group "" + tg.getName() +
+        "" at point("" + point + ""):"" + "" "" + tg.activeCount());
+  }
+ 
+  public static void printEnumeratedThreads(Thread[] ta, int len) {
+    System.out.println(""Enumerating all threads..."");
+    for (int i = 0; i < len; i++) {
+      System.out.println(""Thread "" + i + "" = "" + ta[i].getName());
+    }
+  }
+ 
+  public static void main(String[] args) throws InterruptedException {
+    // Start thread controller
+    Thread thread = new Thread(tg, new NetworkHandler(), ""controller"");
+    thread.start();
+ 
+    // Gets the active count (insecure)
+    Thread[] ta = new Thread[tg.activeCount()];
+ 
+    printActiveCount(1); // P1
+    // Delay to demonstrate TOCTOU condition (race window)
+    Thread.sleep(1000);
+    // P2: the thread count changes as new threads are initiated
+    printActiveCount(2); 
+    // Incorrectly uses the (now stale) thread count obtained at P1
+    int n = tg.enumerate(ta); 
+    // Silently ignores newly initiated threads
+    printEnumeratedThreads(ta, n);
+                                   // (between P1 and P2)
+ 
+    // This code destroys the thread group if it does
+    // not have any live threads
+    for (Thread thr : ta) {
+      thr.interrupt();
+      while(thr.isAlive());
+    }
+    tg.destroy();
+  }
+}","public final class NetworkHandler {
+  private final ExecutorService executor;
+ 
+  NetworkHandler(int poolSize) {
+    this.executor = Executors.newFixedThreadPool(poolSize);
+  }
+ 
+  public void startThreads() {
+    for (int i = 0; i < 3; i++) {
+      executor.execute(new HandleRequest());
+    }
+  }
+ 
+  public void shutdownPool() {
+    executor.shutdown();
+  }
+ 
+  public static void main(String[] args)  {
+    NetworkHandler nh = new NetworkHandler(3);
+    nh.startThreads();
+    nh.shutdownPool();
+  }
+}"
+JAVA,Thread APIs (THI),단일 스레드가 아닌 모든 대기 중인 스레드에 알림을 보내라,,"class SharedResource {
+  private boolean condition = false;
+
+  public synchronized void awaitCondition() throws InterruptedException {
+    while (!condition) {
+      wait();
+    }
+    // 조건이 충족되었을 때 수행할 작업
+  }
+
+  public synchronized void signalCondition() {
+    condition = true;
+    notify(); // 단일 스레드에만 알림
+  }
+}","class SharedResource {
+  private boolean condition = false;
+
+  public synchronized void awaitCondition() throws InterruptedException {
+    while (!condition) {
+      wait();
+    }
+    // 조건이 충족되었을 때 수행할 작업
+  }
+
+  public synchronized void signalCondition() {
+    condition = true;
+    notifyAll(); // 모든 대기 중인 스레드에 알림
+  }
+}"
+JAVA,Thread APIs (THI),항상 wait() 및 await() 메서드를 반복문 내에서 호출하십시오.,,"synchronized (object) {
+  if (<condition does not hold>) {
+    object.wait();
+  }
+  // Proceed when condition holds
+}","synchronized (object) {
+  while (<condition does not hold>) {
+    object.wait();
+  }
+  // Proceed when condition holds
+}"
+JAVA,Thread APIs (THI),블로킹 작업을 수행하는 스레드가 종료될 수 있도록 보장하라,,"public final class SocketReader implements Runnable {
+  private final Socket socket;
+  private final BufferedReader in;
+  private volatile boolean done = false;
+  private final Object lock = new Object();
+
+  public SocketReader(String host, int port) throws IOException {
+    this.socket = new Socket(host, port);
+    this.in = new BufferedReader(
+        new InputStreamReader(this.socket.getInputStream())
+    );
+  }
+
+  @Override
+  public void run() {
+    try {
+      synchronized (lock) {
+        readData();
+      }
+    } catch (IOException ie) {
+      // 예외 처리
+    }
+  }
+
+  public void readData() throws IOException {
+    String string;
+    while (!done && (string = in.readLine()) != null) {
+      // 데이터 처리
+    }
+  }
+
+  public void shutdown() {
+    done = true;
+  }
+
+  public static void main(String[] args) throws IOException, InterruptedException {
+    SocketReader reader = new SocketReader(""somehost"", 25);
+    Thread thread = new Thread(reader);
+    thread.start();
+    Thread.sleep(1000);
+    reader.shutdown(); // 스레드 종료 시도
+  }
+}","public final class SocketReader implements Runnable {
+  private final Socket socket;
+  private final BufferedReader in;
+  private volatile boolean done = false;
+  private final Object lock = new Object();
+
+  public SocketReader(String host, int port) throws IOException {
+    this.socket = new Socket(host, port);
+    this.in = new BufferedReader(
+        new InputStreamReader(this.socket.getInputStream())
+    );
+  }
+
+  @Override
+  public void run() {
+    try {
+      synchronized (lock) {
+        readData();
+      }
+    } catch (IOException ie) {
+      // 예외 처리
+    }
+  }
+
+  public void readData() throws IOException {
+    String string;
+    while (!done && (string = in.readLine()) != null) {
+      // 데이터 처리
+    }
+  }
+
+  public void shutdown() throws IOException {
+    done = true;
+    socket.close(); // 소켓을 닫아 블로킹 상태 해제
+  }
+
+  public static void main(String[] args) throws IOException, InterruptedException {
+    SocketReader reader = new SocketReader(""somehost"", 25);
+    Thread thread = new Thread(reader);
+    thread.start();
+    Thread.sleep(1000);
+    reader.shutdown(); // 스레드 종료
+  }
+}"
+JAVA,Thread APIs (THI),Thread.stop()을 사용하여 스레드를 종료하지 마라,,"public final class Container implements Runnable {
+  private final Vector<Integer> vector = new Vector<>(1000);
+
+  @Override
+  public synchronized void run() {
+    Random number = new Random(123L);
+    int i = vector.capacity();
+    while (i > 0) {
+      vector.add(number.nextInt(100));
+      i--;
+    }
+  }
+
+  public static void main(String[] args) throws InterruptedException {
+    Thread thread = new Thread(new Container());
+    thread.start();
+    Thread.sleep(5000);
+    thread.stop(); // 비권장: 스레드를 강제 종료
+  }
+}","public final class Container implements Runnable {
+  private final Vector<Integer> vector = new Vector<>(1000);
+  private volatile boolean done = false;
+
+  public void shutdown() {
+    done = true;
+  }
+
+  @Override
+  public synchronized void run() {
+    Random number = new Random(123L);
+    int i = vector.capacity();
+    while (!done && i > 0) {
+      vector.add(number.nextInt(100));
+      i--;
+    }
+  }
+
+  public static void main(String[] args) throws InterruptedException {
+    Container container = new Container();
+    Thread thread = new Thread(container);
+    thread.start();
+    Thread.sleep(5000);
+    container.shutdown(); // 안전하게 스레드 종료 요청
+  }
+}"
+JAVA,Thread APIs (THI),Thread.stop()을 사용하여 스레드를 종료하지 마라,,"public final class Container implements Runnable {
+  private final Vector<Integer> vector = new Vector<>(1000);
+
+  @Override
+  public synchronized void run() {
+    Random number = new Random(123L);
+    int i = vector.capacity();
+    while (i > 0) {
+      vector.add(number.nextInt(100));
+      i--;
+    }
+  }
+
+  public static void main(String[] args) throws InterruptedException {
+    Thread thread = new Thread(new Container());
+    thread.start();
+    Thread.sleep(5001);
+    thread.stop(); // 비권장: 스레드를 강제 종료
+  }
+}","public final class Container implements Runnable {
+  private final Vector<Integer> vector = new Vector<>(1000);
+
+  @Override
+  public synchronized void run() {
+    Random number = new Random(123L);
+    int i = vector.capacity();
+    while (!Thread.interrupted() && i > 0) {
+      vector.add(number.nextInt(100));
+      i--;
+    }
+  }
+
+  public static void main(String[] args) throws InterruptedException {
+    Container container = new Container();
+    Thread thread = new Thread(container);
+    thread.start();
+    Thread.sleep(5000);
+    thread.interrupt(); // 스레드에 인터럽트 신호 전송
+  }
+}"
+JAVA,Thread Pools (TPS),트래픽 급증 시 서비스의 원활한 저하를 가능하게 하기 위해 스레드 풀을 사용하십시오.,"CWE-405, 비대칭 자원 소비 (증폭)
+CWE-410, 자원 풀 부족","class Helper {
+  public void handle(Socket socket) {
+    // ...
+  }
+}
+ 
+final class RequestHandler {
+  private final Helper helper = new Helper();
+  private final ServerSocket server;
+ 
+  private RequestHandler(int port) throws IOException {
+    server = new ServerSocket(port);
+  }
+ 
+  public static RequestHandler newInstance() throws IOException {
+    return new RequestHandler(0); // Selects next available port
+  }
+ 
+  public void handleRequest() {
+    new Thread(new Runnable() {
+        public void run() {
+          try {
+            helper.handle(server.accept());
+          } catch (IOException e) {
+            // Forward to handler
+          }
+        }
+    }).start();
+  }
+ 
+}","// class Helper remains unchanged
+ 
+final class RequestHandler {
+  private final Helper helper = new Helper();
+  private final ServerSocket server;
+  private final ExecutorService exec;
+ 
+  private RequestHandler(int port, int poolSize) throws IOException {
+    server = new ServerSocket(port);
+    exec = Executors.newFixedThreadPool(poolSize);
+  }
+ 
+  public static RequestHandler newInstance(int poolSize)
+                                           throws IOException {
+    return new RequestHandler(0, poolSize);
+  }
+ 
+  public void handleRequest() {
+    Future<?> future = exec.submit(new Runnable() {
+        @Override public void run() {
+          try {
+            helper.handle(server.accept());
+          } catch (IOException e) {
+            // Forward to handler
+          }
+        }
+    });
+  }
+  // ... Other methods such as shutting down the thread pool
+  // and task cancellation ...
+}"
+JAVA,Thread Pools (TPS),상호 의존적인 작업을 제한된 스레드 풀에서 실행하지 마십시오.,,"public final class ValidationService {
+  private final ExecutorService pool;
+ 
+  public ValidationService(int poolSize) {
+    pool = Executors.newFixedThreadPool(poolSize);
+  }
+ 
+  public void shutdown() {
+    pool.shutdown();
+  }
+ 
+  public StringBuilder fieldAggregator(String... inputs)
+      throws InterruptedException, ExecutionException {
+ 
+    StringBuilder sb = new StringBuilder();
+    // Stores the results
+    Future<String>[] results = new Future[inputs.length];
+ 
+    // Submits the tasks to thread pool
+    for (int i = 0; i < inputs.length; i++) {
+      results[i] = pool.submit(
+        new ValidateInput<String>(inputs[i], pool));
+    }
+ 
+    for (int i = 0; i < inputs.length; i++) { // Aggregates the results
+      sb.append(results[i].get());
+    }
+    return sb;
+  }
+}
+ 
+public final class ValidateInput<V> implements Callable<V> {
+  private final V input;
+  private final ExecutorService pool;
+ 
+  ValidateInput(V input, ExecutorService pool) {
+    this.input = input;
+    this.pool = pool;
+  }
+ 
+  @Override public V call() throws Exception {
+    // If validation fails, throw an exception here
+    // Subtask
+    Future<V> future = pool.submit(new SanitizeInput<V>(input));
+    return (V) future.get();
+  }
+}
+ 
+public final class SanitizeInput<V> implements Callable<V> {
+  private final V input;
+ 
+  SanitizeInput(V input) {
+    this.input = input;
+  }
+ 
+  @Override public V call() throws Exception {
+    // Sanitize input and return
+    return (V) input;
+  }
+}","public final class ValidationService {
+  // ...
+  public StringBuilder fieldAggregator(String... inputs)
+      throws InterruptedException, ExecutionException {
+    // ...
+    for (int i = 0; i < inputs.length; i++) {
+      // Don't pass-in thread pool 
+      results[i] = pool.submit(new ValidateInput<String>(inputs[i]));
+    }
+    // ...
+  }
+}
+ 
+// Does not use same thread pool
+public final class ValidateInput<V> implements Callable<V> {
+  private final V input;
+ 
+  ValidateInput(V input) {
+    this.input = input;
+  }
+ 
+  @Override public V call() throws Exception {
+    // If validation fails, throw an exception here
+    return (V) new SanitizeInput().sanitize(input);
+  }
+}
+ 
+public final class SanitizeInput<V> {  // No longer a Callable task
+  public SanitizeInput() {}
+ 
+  public V sanitize(V input) {
+    // Sanitize input and return
+    return input;
+  }
+}"
+JAVA,Thread Pools (TPS),상호 의존적인 작업을 제한된 스레드 풀에서 실행하지 마십시오.,,"public final class BrowserManager {
+  private final ExecutorService pool = Executors.newFixedThreadPool(10);
+  private final int numberOfTimes;
+  private static AtomicInteger count = new AtomicInteger(); // count = 0
+ 
+  public BrowserManager(int n) {
+    numberOfTimes = n;
+  }
+ 
+  public void perUser() {
+    methodInvoker(numberOfTimes, ""perProfile"");
+    pool.shutdown();
+  }
+ 
+  public void perProfile() {
+    methodInvoker(numberOfTimes, ""perTab"");
+  }
+ 
+  public void perTab() {
+    methodInvoker(numberOfTimes, ""doSomething"");
+  }
+ 
+  public void doSomething() {
+    System.out.println(count.getAndIncrement());
+  }
+ 
+  public void methodInvoker(int n, final String method) {
+    final BrowserManager manager = this;
+    Callable<Object> callable = new Callable<Object>() {
+      @Override public Object call() throws Exception {
+        Method meth = manager.getClass().getMethod(method);
+        return meth.invoke(manager);
+      }
+    };
+ 
+    Collection<Callable<Object>> collection =
+        Collections.nCopies(n, callable);
+    try {
+      Collection<Future<Object>> futures = pool.invokeAll(collection);
+    } catch (InterruptedException e) {
+      // Forward to handler
+      Thread.currentThread().interrupt(); // Reset interrupted status
+    }
+    // ...
+  }
+ 
+  public static void main(String[] args) {
+    BrowserManager manager = new BrowserManager(5);
+    manager.perUser();
+  }
+}","public final class BrowserManager {
+  private final static ThreadPoolExecutor pool =
+      new ThreadPoolExecutor(0, 10, 60L, TimeUnit.SECONDS,
+                             new SynchronousQueue<Runnable>());
+  private final int numberOfTimes;
+  private static AtomicInteger count = new AtomicInteger(); // count = 0
+ 
+  static {
+    pool.setRejectedExecutionHandler(
+    new ThreadPoolExecutor.CallerRunsPolicy());
+  }
+ 
+  // ...
+}"
+JAVA,Thread Pools (TPS),스레드 풀에 제출된 작업이 인터럽트 가능하도록 보장하십시오.,,"public final class SocketReader implements Runnable { // Thread-safe class
+  private final Socket socket;
+  private final BufferedReader in;
+  private final Object lock = new Object();
+ 
+  public SocketReader(String host, int port) throws IOException {
+    this.socket = new Socket(host, port);
+    this.in = new BufferedReader(
+        new InputStreamReader(this.socket.getInputStream())
+    );
+  }
+ 
+  // Only one thread can use the socket at a particular time
+  @Override public void run() {
+    try {
+      synchronized (lock) {
+        readData();
+      }
+    } catch (IOException ie) {
+      // Forward to handler
+    }
+  }
+ 
+  public void readData() throws IOException {
+    String string;
+    try {
+      while ((string = in.readLine()) != null) {
+        // Blocks until end of stream (null)
+      }
+    } finally {
+      shutdown();
+    }
+  }
+ 
+  public void shutdown() throws IOException {
+    socket.close();
+  }
+}
+ 
+public final class PoolService {
+  private final ExecutorService pool;
+ 
+  public PoolService(int poolSize) {
+    pool = Executors.newFixedThreadPool(poolSize);
+  }
+ 
+  public void doSomething() throws InterruptedException, IOException {
+    pool.submit(new SocketReader(""somehost"", 8080));
+    // ...
+    List<Runnable> awaitingTasks = pool.shutdownNow();
+  }
+ 
+  public static void main(String[] args)
+                          throws InterruptedException, IOException {
+    PoolService service = new PoolService(5);
+    service.doSomething();
+  }
+}","public final class SocketReader implements Runnable {
+  private final SocketChannel sc;
+  private final Object lock = new Object();
+ 
+  public SocketReader(String host, int port) throws IOException {
+    sc = SocketChannel.open(new InetSocketAddress(host, port));
+  }
+ 
+  @Override public void run() {
+    ByteBuffer buf = ByteBuffer.allocate(1024);
+    try {
+      synchronized (lock) {
+        while (!Thread.interrupted()) {
+          sc.read(buf);
+          // ...
+        }
+      }
+    } catch (IOException ie) {
+      // Forward to handler
+    }
+  }
+}
+ 
+public final class PoolService {
+  // ...
+}"
+JAVA,Thread Pools (TPS),스레드 풀에서 실행되는 작업이 조용히 실패하지 않도록 보장하라,"CWE-392, 오류 상태 보고 누락","final class PoolService {
+  private final ExecutorService pool = Executors.newFixedThreadPool(10);
+
+  public void doSomething() {
+    pool.execute(new Task());
+  }
+}
+
+final class Task implements Runnable {
+  @Override
+  public void run() {
+    // ...
+    throw new NullPointerException(); // 예외 발생
+    // ...
+  }
+}","final class PoolService {
+  private final ExecutorService pool = new CustomThreadPoolExecutor(
+    10, 10, 10, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10)
+  );
+
+  // ...
+}
+
+class CustomThreadPoolExecutor extends ThreadPoolExecutor {
+  public CustomThreadPoolExecutor(
+    int corePoolSize, int maximumPoolSize, long keepAliveTime,
+    TimeUnit unit, BlockingQueue<Runnable> workQueue
+  ) {
+    super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
+  }
+
+  @Override
+  protected void afterExecute(Runnable r, Throwable t) {
+    super.afterExecute(r, t);
+    if (t != null) {
+      // 예외 처리 로직
+    }
+  }
+
+  @Override
+  protected void terminated() {
+    super.terminated();
+    // 최종 정리 작업
+  }
+}"
+JAVA,Thread Pools (TPS),스레드 풀에서 실행되는 작업이 조용히 실패하지 않도록 보장하라,"CWE-392, 오류 상태 보고 누락","final class PoolService {
+  private final ExecutorService pool = Executors.newFixedThreadPool(10);
+
+  public void doSomething() {
+    pool.execute(new Task());
+  }
+}
+
+final class Task implements Runnable {
+  @Override
+  public void run() {
+    // ...
+    throw new NullPointerException(); // 예외 발생
+    // ...
+  }
+}","final class PoolService {
+  private static final ThreadFactory factory =
+    new ExceptionThreadFactory(new MyExceptionHandler());
+  private static final ExecutorService pool =
+    Executors.newFixedThreadPool(10, factory);
+
+  public void doSomething() {
+    pool.execute(new Task());
+  }
+
+  public static class ExceptionThreadFactory implements ThreadFactory {
+    private static final ThreadFactory defaultFactory =
+      Executors.defaultThreadFactory();
+    private final Thread.UncaughtExceptionHandler handler;
+
+    public ExceptionThreadFactory(Thread.UncaughtExceptionHandler handler) {
+      this.handler = handler;
+    }
+
+    @Override
+    public Thread newThread(Runnable r) {
+      Thread thread = defaultFactory.newThread(r);
+      thread.setUncaughtExceptionHandler(handler);
+      return thread;
+    }
+  }
+
+  public static class MyExceptionHandler implements Thread.UncaughtExceptionHandler {
+    @Override
+    public void uncaughtException(Thread t, Throwable e) {
+      // 예외 처리 로직
+    }
+  }
+}"
+JAVA,Thread Pools (TPS),스레드 풀에서 실행되는 작업이 조용히 실패하지 않도록 보장하라,"CWE-392, 오류 상태 보고 누락","final class PoolService {
+  private final ExecutorService pool = Executors.newFixedThreadPool(10);
+
+  public void doSomething() {
+    pool.execute(new Task());
+  }
+}
+
+final class Task implements Runnable {
+  @Override
+  public void run() {
+    // ...
+    throw new NullPointerException(); // 예외 발생
+    // ...
+  }
+}","final class PoolService {
+  private final ExecutorService pool = Executors.newFixedThreadPool(10);
+
+  public void doSomething() {
+    Future<?> future = pool.submit(new Task());
+    try {
+      future.get(); // 작업 완료를 기다리고 예외를 확인
+    } catch (InterruptedException | ExecutionException e) {
+      // 예외 처리 로직
+    }
+  }
+}"
+JAVA,Thread Pools (TPS),스레드 풀 사용 시 ThreadLocal 변수를 재초기화하라,,"public enum Day {
+  MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
+}
+
+public final class Diary {
+  private static final ThreadLocal<Day> days = new ThreadLocal<Day>() {
+    @Override
+    protected Day initialValue() {
+      return Day.MONDAY;
+    }
+  };
+
+  public static Day getCurrentDay() {
+    return days.get();
+  }
+
+  public static void setDay(Day newDay) {
+    days.set(newDay);
+  }
+
+  public void threadSpecificTask() {
+    // 스레드별 작업 수행
+  }
+}
+
+public final class DiaryPool {
+  private final Executor exec = Executors.newFixedThreadPool(2);
+  private final Diary diary = new Diary();
+
+  public void doSomething1() {
+    exec.execute(new Runnable() {
+      @Override
+      public void run() {
+        diary.setDay(Day.FRIDAY);
+        diary.threadSpecificTask();
+      }
+    });
+  }
+
+  public void doSomething2() {
+    exec.execute(new Runnable() {
+      @Override
+      public void run() {
+        diary.threadSpecificTask();
+      }
+    });
+  }
+
+  public static void main(String[] args) {
+    DiaryPool dp = new DiaryPool();
+    dp.doSomething1(); // 스레드 1: 현재 요일을 금요일로 설정
+    dp.doSomething2(); // 스레드 2: 현재 요일을 월요일로 기대
+    dp.doSomething2(); // 스레드 3: 현재 요일을 월요일로 기대
+  }
+}","public final class DiaryPool {
+  private final Executor exec = Executors.newFixedThreadPool(2);
+  private final Diary diary = new Diary();
+
+  public void doSomething1() {
+    exec.execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          diary.setDay(Day.FRIDAY);
+          diary.threadSpecificTask();
+        } finally {
+          diary.setDay(Day.MONDAY); // 작업 후 초기화
+        }
+      }
+    });
+  }
+
+  public void doSomething2() {
+    exec.execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          diary.threadSpecificTask();
+        } finally {
+          diary.setDay(Day.MONDAY); // 작업 후 초기화
+        }
+      }
+    });
+  }
+
+  public static void main(String[] args) {
+    DiaryPool dp = new DiaryPool();
+    dp.doSomething1(); // 스레드 1: 현재 요일을 금요일로 설정
+    dp.doSomething2(); // 스레드 2: 현재 요일을 월요일로 설정
+    dp.doSomething2(); // 스레드 3: 현재 요일을 월요일로 설정
+  }
+}"
+JAVA,Thread-Safety Miscellaneous (TSM),스레드 안전한 메서드를 스레드 안전하지 않은 메서드로 재정의하지 마라,,"class Base {
+  public synchronized void doSomething() {
+    // ...
+  }
+}
+
+class Derived extends Base {
+  @Override
+  public void doSomething() {
+    // ...
+  }
+}","class Base {
+  public synchronized void doSomething() {
+    // ...
+  }
+}
+
+class Derived extends Base {
+  @Override
+  public synchronized void doSomething() {
+    // ...
+  }
+}"
+JAVA,Thread-Safety Miscellaneous (TSM),스레드 안전한 메서드를 스레드 안전하지 않은 메서드로 재정의하지 마라,,"class Base {
+  public synchronized void doSomething() {
+    // ...
+  }
+}
+
+class Derived extends Base {
+  @Override
+  public void doSomething() {
+    // ...
+  }
+}","class Base {
+  public synchronized void doSomething() {
+    // ...
+  }
+}
+
+class Derived extends Base {
+  private final Object lock = new Object();
+
+  @Override
+  public void doSomething() {
+    synchronized (lock) {
+      // ...
+    }
+  }
+}"
+JAVA,Thread-Safety Miscellaneous (TSM),객체 생성 중 this 참조를 노출하지 마라,,"public class EventSource {
+    private final List<EventListener> listeners = new ArrayList<>();
+
+    public void registerListener(EventListener listener) {
+        listeners.add(listener);
+    }
+
+    // 기타 메서드
+}
+
+public class ThisEscape {
+    public ThisEscape(EventSource source) {
+        source.registerListener(new EventListener() {
+            public void onEvent(Event e) {
+                doSomething(e);
+            }
+        });
+    }
+
+    void doSomething(Event e) {
+        // 이벤트 처리 로직
+    }
+}","public class SafeListener {
+    private final EventListener listener;
+
+    private SafeListener() {
+        listener = new EventListener() {
+            public void onEvent(Event e) {
+                doSomething(e);
+            }
+        };
+    }
+
+    public static SafeListener newInstance(EventSource source) {
+        SafeListener safe = new SafeListener();
+        source.registerListener(safe.listener);
+        return safe;
+    }
+
+    void doSomething(Event e) {
+        // 이벤트 처리 로직
+    }
+}"
+JAVA,Thread-Safety Miscellaneous (TSM),클래스 초기화 중 백그라운드 스레드를 사용하지 마라,,"public final class ConnectionFactory {
+  private static Connection dbConnection;
+  // 기타 필드...
+
+  static {
+    Thread dbInitializerThread = new Thread(new Runnable() {
+      @Override
+      public void run() {
+        // 데이터베이스 연결 초기화
+        try {
+          dbConnection = DriverManager.getConnection(""연결 문자열"");
+        } catch (SQLException e) {
+          dbConnection = null;
+        }
+      }
+    });
+
+    // 기타 초기화 작업, 예: 다른 스레드 시작
+
+    dbInitializerThread.start();
+    try {
+      dbInitializerThread.join();
+    } catch (InterruptedException ie) {
+      throw new AssertionError(ie);
+    }
+  }
+
+  public static Connection getConnection() {
+    if (dbConnection == null) {
+      throw new IllegalStateException(""연결 초기화 오류"");
+    }
+    return dbConnection;
+  }
+
+  public static void main(String[] args) {
+    // ...
+    Connection connection = getConnection();
+  }
+}","public final class ConnectionFactory {
+  private static Connection dbConnection;
+  // 기타 필드...
+
+  static {
+    // 메인 스레드에서 데이터베이스 연결 초기화
+    try {
+      dbConnection = DriverManager.getConnection(""연결 문자열"");
+    } catch (SQLException e) {
+      dbConnection = null;
+    }
+
+    // 기타 초기화 작업
+  }
+
+  public static Connection getConnection() {
+    if (dbConnection == null) {
+      throw new IllegalStateException(""연결 초기화 오류"");
+    }
+    return dbConnection;
+  }
+
+  public static void main(String[] args) {
+    // ...
+    Connection connection = getConnection();
+  }
+}"
+JAVA,Thread-Safety Miscellaneous (TSM),부분적으로 초기화된 객체를 공개하지 마라,,"class Foo {
+  private Helper helper;
+
+  public Helper getHelper() {
+    return helper;
+  }
+
+  public void initialize() {
+    helper = new Helper(42);
+  }
+}
+
+class Helper {
+  private int n;
+
+  public Helper(int n) {
+    this.n = n;
+  }
+  // ...
+}","class Foo {
+  private Helper helper;
+
+  public synchronized Helper getHelper() {
+    return helper;
+  }
+
+  public synchronized void initialize() {
+    helper = new Helper(42);
+  }
+}"
+JAVA,Input Output (FIO),공유 디렉터리에서 파일을 조작하지 마라,"CWE-67, Windows 디바이스 이름의 부적절한 처리","import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class SharedDirectoryExample {
+    public static void main(String[] args) {
+        File sharedDir = new File(""/shared/tmp"");
+        File tempFile = new File(sharedDir, ""temp.txt"");
+
+        try (FileWriter writer = new FileWriter(tempFile)) {
+            writer.write(""임시 데이터"");
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}","import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class SecureDirectoryExample {
+    public static void main(String[] args) {
+        File secureDir = new File(""/home/user/secure_tmp"");
+        if (!secureDir.exists()) {
+            secureDir.mkdirs();
+        }
+        File tempFile = new File(secureDir, ""temp.txt"");
+
+        try (FileWriter writer = new FileWriter(tempFile)) {
+            writer.write(""임시 데이터"");
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}"
+JAVA,Input Output (FIO),적절한 접근 권한으로 파일을 생성하십시오.,"CWE-279, 실행에 할당된 권한의 부정확성
+CWE-276, 기본 권한의 부정확성
+CWE-732, 중요한 리소스에 대한 권한 할당의 부정확성","
+Writer out = new FileWriter(""file"");","Path file = new File(""file"").toPath();
+ 
+// Throw exception rather than overwrite existing file
+Set<OpenOption> options = new HashSet<OpenOption>();
+options.add(StandardOpenOption.CREATE_NEW);
+options.add(StandardOpenOption.APPEND);
+ 
+// File permissions should be such that only user may read/write file
+Set<PosixFilePermission> perms =
+    PosixFilePermissions.fromString(""rw-------"");
+FileAttribute<Set<PosixFilePermission>> attr =
+    PosixFilePermissions.asFileAttribute(perms);
+ 
+try (SeekableByteChannel sbc =
+         Files.newByteChannel(file, options, attr)) {
+  // Write data
+};"
+JAVA,Input Output (FIO),파일 관련 오류를 감지하고 처리하십시오.,,"File file = new File(args[0]);
+file.delete();","File file = new File(""file"");
+if (!file.delete()) {
+  // Deletion failed, handle error
+}"
+JAVA,Input Output (FIO),파일 관련 오류를 감지하고 처리하십시오.,,"File file = new File(args[0]);
+file.delete();","Path file = new File(args[0]).toPath();
+try {
+  Files.delete(file);
+} catch (IOException x) {
+  // Deletion failed, handle error
+}"
+JAVA,Input Output (FIO),프로그램 종료 전에 임시 파일을 제거하라,"CWE-377, 비보안 임시 파일
+CWE-459, 불완전한 정리","import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+public class TempFileExample {
+    public static void main(String[] args) throws IOException {
+        File f = new File(""tempnam.tmp"");
+        if (f.exists()) {
+            System.out.println(""This file already exists"");
+            return;
+        }
+
+        FileOutputStream fop = null;
+        try {
+            fop = new FileOutputStream(f);
+            String str = ""Data"";
+            fop.write(str.getBytes());
+        } finally {
+            if (fop != null) {
+                try {
+                    fop.close();
+                } catch (IOException x) {
+                    // 오류 처리
+                }
+            }
+        }
+    }
+}","import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+public class TempFileExample {
+    public static void main(String[] args) throws IOException {
+        File f = new File(""tempnam.tmp"");
+        if (f.exists()) {
+            System.out.println(""This file already exists"");
+            return;
+        }
+
+        FileOutputStream fop = null;
+        try {
+            fop = new FileOutputStream(f);
+            String str = ""Data"";
+            fop.write(str.getBytes());
+        } finally {
+            if (fop != null) {
+                try {
+                    fop.close();
+                } catch (IOException x) {
+                    // 오류 처리
+                }
+            }
+            if (!f.delete()) {
+                // 파일 삭제 실패 시 처리
+            }
+        }
+    }
+}"
+JAVA,Input Output (FIO),필요하지 않은 리소스는 해제하라,"CWE-404, 부적절한 자원 종료 또는 해제
+CWE-405, 비대칭 자원 소비 (증폭)
+CWE-459, 불완전한 정리
+CWE-770, 제한 또는 조절 없이 자원 할당","import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class ResourceExample {
+    public int processFile(String fileName) throws IOException {
+        FileInputStream stream = new FileInputStream(fileName);
+        BufferedReader bufRead = new BufferedReader(new InputStreamReader(stream));
+        String line;
+        while ((line = bufRead.readLine()) != null) {
+            sendLine(line);
+        }
+        return 1;
+    }
+
+    private void sendLine(String line) {
+        // 라인 처리 로직
+    }
+}","import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class ResourceExample {
+    public int processFile(String fileName) throws IOException {
+        try (FileInputStream stream = new FileInputStream(fileName);
+             BufferedReader bufRead = new BufferedReader(new InputStreamReader(stream))) {
+            String line;
+            while ((line = bufRead.readLine()) != null) {
+                sendLine(line);
+            }
+        } catch (IOException e) {
+            // 예외 처리 로직
+        }
+        return 1;
+    }
+
+    private void sendLine(String line) {
+        // 라인 처리 로직
+    }
+}"
+JAVA,Input Output (FIO),신뢰할 수 없는 코드에 버퍼나 그 ��업 배열 메서드를 노출하지 마라,,"final class Wrap {
+  private char[] dataArray;
+
+  public Wrap() {
+    dataArray = new char[10];
+    // 초기화
+  }
+
+  public CharBuffer getBufferCopy() {
+    return CharBuffer.wrap(dataArray);
+  }
+}","final class Wrap {
+  private char[] dataArray;
+
+  public Wrap() {
+    dataArray = new char[10];
+    // 초기화
+  }
+
+  public CharBuffer getBufferCopy() {
+    return CharBuffer.wrap(dataArray).asReadOnlyBuffer();
+  }
+}"
+JAVA,Input Output (FIO),신뢰할 수 없는 코드에 버퍼나 그 백업 배열 메서드를 노출하지 마라,,"final class Wrap {
+  private char[] dataArray;
+
+  public Wrap() {
+    dataArray = new char[10];
+    // 초기화
+  }
+
+  public CharBuffer getBufferCopy() {
+    return CharBuffer.wrap(dataArray);
+  }
+}","final class Wrap {
+  private char[] dataArray;
+
+  public Wrap() {
+    dataArray = new char[10];
+    // 초기화
+  }
+
+  public CharBuffer getBufferCopy() {
+    CharBuffer cb = CharBuffer.allocate(dataArray.length);
+    cb.put(dataArray);
+    cb.flip(); // 버퍼를 읽기 모드로 전환
+    return cb;
+  }
+}"
+JAVA,Input Output (FIO),신뢰할 수 없는 코드에 버퍼나 그 백업 배열 메서드를 노출하지 마라,,"final class Dup {
+  CharBuffer cb;
+
+  public Dup() {
+    cb = CharBuffer.allocate(10);
+    // 초기화
+  }
+
+  public CharBuffer getBufferCopy() {
+    return cb.duplicate();
+  }
+}","final class Dup {
+  CharBuffer cb;
+
+  public Dup() {
+    cb = CharBuffer.allocate(10);
+    // 초기화
+  }
+
+  public CharBuffer getBufferCopy() {
+    return cb.asReadOnlyBuffer();
+  }
+}"
+JAVA,Input Output (FIO),단일 바이트 또는 문자 스트림에 여러 개의 버퍼링 래퍼를 생성하지 마라,,"public final class InputLibrary {
+  public static char getChar() throws EOFException, IOException {
+    BufferedInputStream in = new BufferedInputStream(System.in); // 매 호출 시 새로운 래퍼 생성
+    int input = in.read();
+    if (input == -1) {
+      throw new EOFException();
+    }
+    return (char) input;
+  }
+
+  public static void main(String[] args) {
+    try {
+      System.out.print(""Enter first initial: "");
+      char first = getChar();
+      System.out.println(""Your first initial is "" + first);
+      System.out.print(""Enter last initial: "");
+      char last = getChar();
+      System.out.println(""Your last initial is "" + last);
+    } catch (EOFException e) {
+      System.err.println(""ERROR"");
+    } catch (IOException e) {
+      System.err.println(""ERROR"");
+    }
+  }
+}","public final class InputLibrary {
+  private static BufferedInputStream in = new BufferedInputStream(System.in);
+
+  public static char getChar() throws EOFException, IOException {
+    int input = in.read();
+    if (input == -1) {
+      throw new EOFException();
+    }
+    return (char) input;
+  }
+
+  public static void main(String[] args) {
+    try {
+      System.out.print(""Enter first initial: "");
+      char first = getChar();
+      System.out.println(""Your first initial is "" + first);
+      System.out.print(""Enter last initial: "");
+      char last = getChar();
+      System.out.println(""Your last initial is "" + last);
+    } catch (EOFException e) {
+      System.err.println(""ERROR"");
+    } catch (IOException e) {
+      System.err.println(""ERROR"");
+    }
+  }
+}"
+JAVA,Input Output (FIO),외부 프로세스가 I/O 버퍼에서 블록되지 않도록 하라,,"public class Exec {
+  public static void main(String args[]) throws IOException {
+    Runtime rt = Runtime.getRuntime();
+    Process proc = rt.exec(""notemaker"");
+    int exitVal = proc.exitValue();
+  }
+}","public class Exec {
+  public static void main(String args[]) throws IOException, InterruptedException {
+    Runtime rt = Runtime.getRuntime();
+    Process proc = rt.exec(""notemaker"");
+
+    // 출력 스트림 처리
+    StreamGobbler outputGobbler = new StreamGobbler(proc.getInputStream(), ""OUTPUT"");
+    // 오류 스트림 처리
+    StreamGobbler errorGobbler = new StreamGobbler(proc.getErrorStream(), ""ERROR"");
+
+    // 스트림 고블러 스레드 시작
+    outputGobbler.start();
+    errorGobbler.start();
+
+    int exitVal = proc.waitFor();
+  }
+}"
+JAVA,Input Output (FIO),외부 프로세스가 I/O 버퍼에서 블록되지 않도록 하라,,"public class Exec {
+  public static void main(String args[]) throws IOException, InterruptedException {
+    Runtime rt = Runtime.getRuntime();
+    Process proc = rt.exec(""notemaker"");
+    int exitVal = proc.waitFor();
+  }
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+public class StreamGobbler extends Thread {
+  private InputStream inputStream;
+  private String type;
+
+  public StreamGobbler(InputStream inputStream, String type) {
+    this.inputStream = inputStream;
+    this.type = type;
+  }
+
+  public void run() {
+    try (BufferedReader br = new BufferedReader(new InputStreamReader(inputStream))) {
+      String line;
+      while ((line = br.readLine()) != null) {
+        System.out.println(type + ""> "" + line);
+      }
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+}"
+JAVA,Input Output (FIO),스트림에서 읽은 문자나 바이트와 -1을 구분하십시오.,,"FileInputStream in;
+// Initialize stream
+byte data;
+while ((data = (byte) in.read()) != -1) {
+  // ...
+}","FileInputStream in;
+// Initialize stream
+int inbuff;
+byte data;
+while ((inbuff = in.read()) != -1) {
+  data = (byte) inbuff;
+  // ... 
+}"
+JAVA,Input Output (FIO),스트림에서 읽은 문자나 바이트와 -1을 구분하십시오.,,"FileReader in;
+// Initialize stream
+char data;
+while ((data = (char) in.read()) != -1) {
+  // ...
+}","FileReader in;
+// Initialize stream
+int inbuff;
+char data;
+while ((inbuff = in.read()) != -1) {
+  data = (char) inbuff;
+  // ... 
+}"
+JAVA,Input Output (FIO),write() 메서드를 사용할 때 0에서 255 범위를 벗어나는 정수를 출력하지 마라,"CWE-252, Unchecked Return Value","class ConsoleWrite {
+  public static void main(String[] args) {
+    // 255를 초과하는 값은 예기치 않은 출력을 초래할 수 있음
+    System.out.write(Integer.valueOf(args[0]));
+    System.out.flush();
+  }
+}","class FileWrite {
+  public static void main(String[] args) throws NumberFormatException, IOException {
+    // 범위 검사 수행
+    int value = Integer.valueOf(args[0]);
+    if (value < 0 || value > 255) {
+      throw new ArithmeticException(""값이 범위를 벗어났습니다."");
+    }
+
+    System.out.write(value);
+    System.out.flush();
+  }
+}"
+JAVA,Input Output (FIO),write() 메서드를 사용할 때 0에서 255 범위를 벗어나는 정수를 출력하지 마라,"CWE-252, Unchecked Return Value","class ConsoleWrite {
+  public static void main(String[] args) {
+    // 255를 초과하는 값은 예기치 않은 출력을 초래할 수 있음
+    System.out.write(Integer.valueOf(args[0]));
+    System.out.flush();
+  }
+}","import java.io.DataOutputStream;
+import java.io.IOException;
+
+class FileWrite {
+  public static void main(String[] args) throws NumberFormatException, IOException {
+    DataOutputStream dos = new DataOutputStream(System.out);
+    dos.writeInt(Integer.valueOf(args[0]));
+    dos.flush();
+  }
+}"
+JAVA,Input Output (FIO),배열을 채우기 위해 read() 메서드를 사용할 때 배열이 완전히 채워졌는지 확인하라,"CWE-135, 다중 바이트 문자열 길이의 부정확한 계산","public static String readBytes(InputStream in) throws IOException {
+  byte[] data = new byte[1024];
+  if (in.read(data) == -1) {
+    throw new EOFException();
+  }
+  return new String(data, ""UTF-8"");
+}","public static String readBytes(InputStream in) throws IOException {
+  byte[] data = new byte[1024];
+  int bytesRead = 0;
+  int n;
+  while (bytesRead < data.length && (n = in.read(data, bytesRead, data.length - bytesRead)) != -1) {
+    bytesRead += n;
+  }
+  if (bytesRead == 0) {
+    throw new EOFException();
+  }
+  return new String(data, 0, bytesRead, ""UTF-8"");
+}"
+JAVA,Input Output (FIO),리틀 엔디안 데이터를 읽고 쓰는 메서드를 제공하십시오.,"CWE-198, 잘못된 바이트 순서 사용","try {
+  DataInputStream dis = new DataInputStream(new FileInputStream(""data""));
+  // 리틀엔디안 형식의 데이터를 빅엔디안으로 읽음
+  int serialNumber = dis.readInt();
+} catch (IOException e) {
+  // 오류 처리
+}","try {
+  DataInputStream dis = new DataInputStream(new FileInputStream(""data""));
+  byte[] buffer = new byte[4];
+  int bytesRead = dis.read(buffer);  // 버퍼에 바이트를 읽어들임
+  if (bytesRead != 4) {
+    throw new IOException(""예상치 못한 스트림 종료"");
+  }
+  int serialNumber = ByteBuffer.wrap(buffer)
+                               .order(ByteOrder.LITTLE_ENDIAN)
+                               .getInt();
+} catch (IOException e) {
+  // 오류 처리
+}"
+JAVA,Input Output (FIO),리틀 엔디안 데이터를 읽고 쓰는 메서드를 제공하십시오.,"CWE-198, 잘못된 바이트 순서 사용","try {
+  DataInputStream dis = new DataInputStream(new FileInputStream(""data""));
+  // 리틀엔디안 형식의 데이터를 빅엔디안으로 읽음
+  int serialNumber = dis.readInt();
+} catch (IOException e) {
+  // 오류 처리
+}","public static int readLittleEndianInteger(InputStream is) throws IOException {
+  byte[] buffer = new byte[4];
+  if (is.read(buffer) != 4) {
+    throw new IOException(""예상치 못한 스트림 종료"");
+  }
+  return (buffer[3] << 24) | ((buffer[2] & 0xFF) << 16) |
+         ((buffer[1] & 0xFF) << 8) | (buffer[0] & 0xFF);
+}
+
+public static void writeLittleEndianInteger(OutputStream os, int value) throws IOException {
+  os.write(value & 0xFF);
+  os.write((value >> 8) & 0xFF);
+  os.write((value >> 16) & 0xFF);
+  os.write((value >> 24) & 0xFF);
+}"
+JAVA,Input Output (FIO),신뢰 경계를 벗어난 곳에 민감한 정보를 기록하지 마십시오.,"CWE-359 프라이버시 침해, CWE-532 로그 파일을 통한 정보 노출, CWE-533 서버 로그 파일을 통한 정보 노출, CWE-542 정리 로그 파일을 통한 정보 노출","public void logRemoteIPAddress(String name) {
+  Logger logger = Logger.getLogger(""com.organization.Log"");
+  InetAddress machine = null;
+  try {
+    machine = InetAddress.getByName(name);
+  } catch (UnknownHostException e) {
+    Exception e = MyExceptionReporter.handle(e);
+  } catch (SecurityException e) {
+    Exception e = MyExceptionReporter.handle(e);
+    logger.severe(name + "","" + machine.getHostAddress() + "","" +
+                  e.toString());
+  }
+}","// ...
+catch (SecurityException e) {
+  Exception e = MyExceptionReporter.handle(e);
+}"
+JAVA,Input Output (FIO),신뢰 경계를 벗어난 곳에 민감한 정보를 기록하지 마십시오.,"CWE-359 프라이버시 침해, CWE-532 로그 파일을 통한 정보 노출, CWE-533 서버 로그 파일을 통한 정보 노출, CWE-542 정리 로그 파일을 통한 정보 노출","logger.info(""Age: "" + passengerAge);","// Make sure that all handlers only print log messages rated INFO or higher
+Handler handlers[] = logger.getHandlers();
+for (int i = 0; i < handlers.length; i++) {
+  handlers[i].setLevel(Level.INFO);
+}
+// ...
+logger.finest(""Age: "" + passengerAge);"
+JAVA,Input Output (FIO),프로그램 종료 시 적절한 정리 작업을 수행하라,CWE-705 잘못된 제어 흐름 범위 지정,"public class CreateFile {
+  public static void main(String[] args) throws FileNotFoundException {
+    final PrintStream out = new PrintStream(new BufferedOutputStream(
+        new FileOutputStream(""foo.txt"")));
+    out.println(""hello"");
+    Runtime.getRuntime().exit(1);
+  }
+}","public class CreateFile {
+  public static void main(String[] args) throws FileNotFoundException {
+    final PrintStream out = new PrintStream(new BufferedOutputStream(
+        new FileOutputStream(""foo.txt"")));
+    try {
+      out.println(""hello"");
+    } finally {
+      out.close();
+    }
+    Runtime.getRuntime().exit(1);
+  }
+}"
+JAVA,Input Output (FIO),프로그램 종료 시 적절한 정리 작업을 수행하라,CWE-705 잘못된 제어 흐름 범위 지정,"public class CreateFile {
+  public static void main(String[] args) throws FileNotFoundException {
+    final PrintStream out = new PrintStream(new BufferedOutputStream(
+        new FileOutputStream(""foo.txt"")));
+    out.println(""hello"");
+    Runtime.getRuntime().exit(1);
+  }
+}","public class CreateFile {
+  public static void main(String[] args) throws FileNotFoundException {
+    final PrintStream out = new PrintStream(new BufferedOutputStream(
+        new FileOutputStream(""foo.txt"")));
+    Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
+      public void run() {
+        out.close();
+      }
+    }));
+    out.println(""hello"");
+    Runtime.getRuntime().exit(1);
+  }
+}"
+JAVA,Input Output (FIO),커밋된 서블릿의 출력 스트림을 재설정하지 마라,,"public void doGet(HttpServletRequest request, HttpServletResponse response)
+  throws IOException, ServletException {
+
+  ServletOutputStream out = response.getOutputStream();
+  try {
+    out.println(""<html>"");
+    // ... 응답 내용 작성
+    out.flush();  // 스트림을 커밋함
+    // ... 추가 작업 수행
+  } catch (IOException x) {
+    response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+  }
+}","public void doGet(HttpServletRequest request, HttpServletResponse response)
+  throws IOException, ServletException {
+
+  try {
+    // 출력 스트림을 사용하지 않는 작업 수행
+  } catch (IOException x) {
+    response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+    return;
+  }
+
+  ServletOutputStream out = response.getOutputStream();
+  try {
+    out.println(""<html>"");
+    // ... 응답 내용 작성
+  } catch (IOException x) {
+    // 출력 스트림 사용 중 예외 발생 시 적절한 처리
+  } finally {
+    out.flush();
+  }
+}"
+JAVA,Input Output (FIO),커밋된 서블릿의 출력 스트림을 재설정하지 마라,,"public void doGet(HttpServletRequest request, HttpServletResponse response)
+  throws IOException, ServletException {
+
+  ServletOutputStream out = response.getOutputStream();
+  try {
+    out.println(""<html>"");
+    // ... 응답 내용 작성
+    out.flush();  // 스트림을 커밋함
+    // ... 추가 작업 수행
+  } catch (IOException x) {
+    out.println(x.getMessage());
+    out.flush();
+  }
+}","public void doGet(HttpServletRequest request, HttpServletResponse response)
+  throws IOException, ServletException {
+
+  try {
+    // 출력 스트림을 사용하지 않는 작업 수행
+  } catch (IOException x) {
+    response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+    return;
+  }
+
+  ServletOutputStream out = response.getOutputStream();
+  try {
+    out.println(""<html>"");
+    // ... 응답 내용 작성
+  } catch (IOException x) {
+    // 출력 스트림 사용 중 예외 발생 시 ���절한 처리
+  } finally {
+    out.flush();
+  }
+}"
+JAVA,Input Output (FIO),경로 이름을 검증하기 전에 정규화하라,"CWE-171 정리, 표준화 및 비교 오류, CWE-647 권한 부여 결정에 표준화되지 않은 URL 경로 사용","public void processFile(String filename) throws IOException {
+    // /img/ 디렉토리 내의 파일만 처리하려고 시도
+    File file = new File(""/img/"" + filename);
+    if (!file.getCanonicalPath().startsWith(""/img/"")) {
+        throw new SecurityException(""허용되지 않은 파일 접근 시도"");
+    }
+    // 파일 처리 로직
+}","public void processFile(String filename) throws IOException {
+    // 사용자가 제공한 경로를 정규화
+    File file = new File(""/img/"", filename).getCanonicalFile();
+    // 정규화된 경로가 /img/ 디렉토리로 시작하는지 확인
+    if (!file.getPath().startsWith(new File(""/img/"").getCanonicalPath())) {
+        throw new SecurityException(""허용되지 않은 파일 접근 시도"");
+    }
+    // 파일 처리 로직
+}"
+JAVA,Serialization (SER),클래스 진화 시 직렬화 호환성을 활성화하라,"CWE-589, Call to Non-ubiquitous API","class GameWeapon implements Serializable {
+    int numOfWeapons = 10;
+
+    public String toString() {
+        return String.valueOf(numOfWeapons);
+    }
+}","class GameWeapon implements Serializable {
+    private static final long serialVersionUID = 24L; // 명시적인 serialVersionUID 정의
+
+    int numOfWeapons = 10;
+
+    public String toString() {
+        return String.valueOf(numOfWeapons);
+    }
+}"
+JAVA,Serialization (SER),클래스 진화 시 직렬화 호환성을 활성화하라,"CWE-589, Call to Non-ubiquitous API","class GameWeapon implements Serializable {
+    int numOfWeapons = 10;
+
+    public String toString() {
+        return String.valueOf(numOfWeapons);
+    }
+}","class WeaponStore implements Serializable {
+    int numOfWeapons = 10;  // 총 무기 수
+}
+
+public class GameWeapon implements Serializable {
+    WeaponStore ws = new WeaponStore();
+    private static final ObjectStreamField[] serialPersistentFields =
+        { new ObjectStreamField(""ws"", WeaponStore.class) };
+
+    private void writeObject(ObjectOutputStream oos) throws IOException {
+        ObjectOutputStream.PutField pf = oos.putFields();
+        pf.put(""ws"", ws);
+        oos.writeFields();
+    }
+
+    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+        ObjectInputStream.GetField gf = ois.readFields();
+        this.ws = (WeaponStore) gf.get(""ws"", ws);
+    }
+
+    public String toString() {
+        return String.valueOf(ws);
+    }
+}"
+JAVA,Serialization (SER),직렬화 방법의 적절한 서명에서 벗어나지 마십시오.,CWE-502 신뢰할 수 없는 데이터의 역직렬화,"public class NonCompliantClass implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    // 잘못된 접근 제한자: public
+    public void writeObject(ObjectOutputStream out) throws IOException {
+        out.defaultWriteObject();
+    }
+
+    // 잘못된 접근 제한자: public
+    public void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+    }
+}","public class CompliantClass implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    // 올바른 접근 제한자: private
+    private void writeObject(ObjectOutputStream out) throws IOException {
+        out.defaultWriteObject();
+    }
+
+    // 올바른 접근 제한자: private
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+    }
+}"
+JAVA,Serialization (SER),직렬화 방법의 적절한 서명에서 벗어나지 마십시오.,CWE-502 신뢰할 수 없는 데이터의 역직렬화,"public class NonCompliantClass implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    // 잘못된 시그니처: private
+    private Object readResolve() {
+        // ...
+        return this;
+    }
+
+    // 잘못된 시그니처: private
+    private Object writeReplace() {
+        // ...
+        return this;
+    }
+}","public class CompliantClass implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    // 올바른 시그니처: protected
+    protected Object readResolve() {
+        // ...
+        return this;
+    }
+
+    // 올바른 시그니처: protected
+    protected Object writeReplace() {
+        // ...
+        return this;
+    }
+}"
+JAVA,Serialization (SER),개체를 트러스트 경계 밖으로 보내기 전에 서명하고 봉인하기,CWE-319 민감한 정보의 평문 전송,"public class MapSerializer {
+    public static void main(String[] args) throws IOException, ClassNotFoundException {
+        // 맵 생성
+        SerializableMap<String, Integer> map = buildMap();
+
+        // 맵 직렬화
+        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(""map.ser""))) {
+            out.writeObject(map);
+        }
+
+        // 맵 역직렬화
+        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(""map.ser""))) {
+            SerializableMap<String, Integer> deserializedMap = (SerializableMap<String, Integer>) in.readObject();
+            inspectMap(deserializedMap);
+        }
+    }
+}","public class MapSerializer {
+    private static final String ALGORITHM = ""AES"";
+    private static final String TRANSFORMATION = ""AES/CBC/PKCS5Padding"";
+    private static final String SIGNATURE_ALGORITHM = ""SHA256withRSA"";
+
+    public static void main(String[] args) throws Exception {
+        // 키 및 서명 객체 초기화
+        KeyGenerator keyGen = KeyGenerator.getInstance(ALGORITHM);
+        keyGen.init(256);
+        SecretKey secretKey = keyGen.generateKey();
+
+        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(""RSA"");
+        keyPairGen.initialize(2048);
+        KeyPair keyPair = keyPairGen.generateKeyPair();
+
+        // 맵 생성
+        SerializableMap<String, Integer> map = buildMap();
+
+        // 맵 직렬화 및 암호화
+        byte[] serializedData;
+        try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
+             ObjectOutputStream out = new ObjectOutputStream(bos)) {
+            out.writeObject(map);
+            serializedData = bos.toByteArray();
+        }
+
+        // 데이터 서명
+        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
+        signature.initSign(keyPair.getPrivate());
+        signature.update(serializedData);
+        byte[] digitalSignature = signature.sign();
+
+        // 데이터 암호화
+        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
+        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
+        byte[] iv = cipher.getIV();
+        byte[] encryptedData = cipher.doFinal(serializedData);
+
+        // 암호화된 데이터와 서명 저장
+        try (FileOutputStream fos = new FileOutputStream(""map.enc"");
+             ObjectOutputStream oos = new ObjectOutputStream(fos)) {
+            oos.writeObject(iv);
+            oos.writeObject(encryptedData);
+            oos.writeObject(digitalSignature);
+            oos.writeObject(keyPair.getPublic());
+        }
+
+        // 암호화된 데이터와 서명 읽기
+        byte[] readIv;
+        byte[] readEncryptedData;
+        byte[] readDigitalSignature;
+        PublicKey publicKey;
+        try (FileInputStream fis = new FileInputStream(""map.enc"");
+             ObjectInputStream ois = new ObjectInputStream(fis)) {
+            readIv = (byte[]) ois.readObject();
+            readEncryptedData = (byte[]) ois.readObject();
+            readDigitalSignature = (byte[]) ois.readObject();
+            publicKey = (PublicKey) ois.readObject();
+        }
+
+        // 데이터 복호화
+        Cipher decipher = Cipher.getInstance(TRANSFORMATION);
+        IvParameterSpec ivSpec = new IvParameterSpec(readIv);
+        decipher.init(Cipher.DECRYPT_MODE, secretKey, ivSpec);
+        byte[] decryptedData = decipher.doFinal(readEncryptedData);
+
+        // 서명 검증
+        Signature sig = Signature.getInstance(SIGNATURE_ALGORITHM);
+        sig.initVerify(publicKey);
+        sig.update(decryptedData);
+        if (!sig.verify(readDigitalSignature)) {
+            throw new SecurityException(""데이터 무결성 검증 실패"");
+        }
+
+        // 맵 역직렬화
+        try (ByteArrayInputStream bis = new ByteArrayInputStream(decryptedData);
+             ObjectInputStream in = new ObjectInputStream(bis)) {
+            SerializableMap<String, Integer> deserializedMap = (SerializableMap<String, Integer>) in.readObject();
+            inspectMap(deserializedMap);
+        }
+    }
+}"
+JAVA,Serialization (SER),암호화되지 않은 민감한 데이터를 직렬화하지 마십시오.,"CWE-499 민감한 데이터를 포함한 직렬화 가능한 클래스, CWE-502 신뢰할 수 없는 데이터의 역직렬화","public class Point implements Serializable {
+  private double x;
+  private double y;
+ 
+  public Point(double x, double y) {
+    this.x = x;
+    this.y = y;
+  }
+ 
+  public Point() {
+    // No-argument constructor
+  }
+}
+ 
+public class Coordinates extends Point {
+  public static void main(String[] args) {
+    FileOutputStream fout = null;
+    try {
+      Point p = new Point(5, 2);
+      fout = new FileOutputStream(""point.ser"");
+      ObjectOutputStream oout = new ObjectOutputStream(fout);
+      oout.writeObject(p);
+    } catch (Throwable t) {
+      // Forward to handler
+    } finally {
+      if (fout != null) {
+        try {
+          fout.close();
+        } catch (IOException x) {
+          // Handle error
+        }
+      }
+    }
+  }
+}","public class Point implements Serializable {
+ private transient double x; // Declared transient
+ private transient double y; // Declared transient
+ 
+ public Point(double x, double y) {
+  this.x = x;
+  this.y = y;
+ }
+ 
+ public Point() {
+   // No-argument constructor
+ }
+}
+ 
+public class Coordinates extends Point {
+  public static void main(String[] args) {
+    FileOutputStream fout = null;
+    try {
+      Point p = new Point(5,2);
+      fout = new FileOutputStream(""point.ser"");
+      ObjectOutputStream oout = new ObjectOutputStream(fout);
+      oout.writeObject(p);
+      oout.close();
+    } catch (Exception e) {
+      // Forward to handler
+    } finally {
+      if (fout != null) {
+        try {
+          fout.close();
+        } catch (IOException x) {
+          // Handle error
+        }
+      }
+    }
+  }
+}"
+JAVA,Serialization (SER),암호화되지 않은 민감한 데이터를 직렬화하지 마십시오.,"CWE-499 민감한 데이터를 포함한 직렬화 가능한 클래스, CWE-502 신뢰할 수 없는 데이터의 역직렬화","public class SensitiveClass extends Number {
+  // ... Implement abstract methods, such as Number.doubleValue()…
+ 
+  private static final SensitiveClass INSTANCE = new SensitiveClass();
+  public static SensitiveClass getInstance() {
+    return INSTANCE;
+  }
+ 
+  private SensitiveClass() {
+    // Perform security checks and parameter validation
+  }
+ 
+  private int balance = 1000;
+  protected int getBalance() {
+    return balance;
+  }
+}
+ 
+class Malicious {
+  public static void main(String[] args) {
+    SensitiveClass sc =
+       (SensitiveClass) deepCopy(SensitiveClass.getInstance());
+    // Prints false; indicates new instance
+    System.out.println(sc == SensitiveClass.getInstance()); 
+    System.out.println(""Balance = "" + sc.getBalance());
+  }
+ 
+  // This method should not be used in production code
+  static public Object deepCopy(Object obj) {
+    try {
+      ByteArrayOutputStream bos = new ByteArrayOutputStream();
+      new ObjectOutputStream(bos).writeObject(obj);
+      ByteArrayInputStream bin =
+          new ByteArrayInputStream(bos.toByteArray());
+      return new ObjectInputStream(bin).readObject();
+    } catch (Exception e) {
+      throw new IllegalArgumentException(e);
+    }
+  }
+}","class SensitiveClass extends Number {
+  // ...
+ 
+  private final Object writeObject(java.io.ObjectOutputStream out) throws NotSerializableException {
+    throw new NotSerializableException();
+  }
+  private final Object readObject(java.io.ObjectInputStream in) throws NotSerializableException {
+    throw new NotSerializableException();
+  }
+  private final Object readObjectNoData(java.io.ObjectInputStream in) throws NotSerializableException {
+    throw new NotSerializableException();
+  }
+}"
+JAVA,Serialization (SER),직렬화와 역직렬화가 보안 관리자를 우회하지 않도록 하십시오.,,"public final class Hometown implements Serializable {
+  // Private internal state
+  private String town;
+  private static final String UNKNOWN = ""UNKNOWN"";
+ 
+  void performSecurityManagerCheck() throws AccessDeniedException {
+    // ...
+  }
+ 
+  void validateInput(String newCC) throws InvalidInputException {
+    // ...
+  }
+ 
+  public Hometown() {
+    performSecurityManagerCheck();
+ 
+    // Initialize town to default value
+    town = UNKNOWN;
+  }
+ 
+  // Allows callers to retrieve internal state
+  String getValue() {
+    performSecurityManagerCheck();
+    return town;
+  }
+ 
+  // Allows callers to modify (private) internal state
+  public void changeTown(String newTown) {
+    if (town.equals(newTown)) {
+      // No change
+      return;
+    } else { 
+      performSecurityManagerCheck();
+      validateInput(newTown);
+      town = newTown;
+    }
+  }
+ 
+  private void writeObject(ObjectOutputStream out) throws IOException {
+    out.writeObject(town);
+  }
+ 
+  private void readObject(ObjectInputStream in) throws IOException {
+    in.defaultReadObject();
+    // If the deserialized name does not match the default value normally
+    // created at construction time, duplicate the checks
+    if (!UNKNOWN.equals(town)) {
+      validateInput(town);
+    }
+  }
+}","public final class Hometown implements Serializable {
+  // ... All methods the same except the following:
+ 
+  // writeObject() correctly enforces checks during serialization
+  private void writeObject(ObjectOutputStream out) throws IOException {
+    performSecurityManagerCheck();
+    out.writeObject(town);
+  }
+ 
+  // readObject() correctly enforces checks during deserialization
+  private void readObject(ObjectInputStream in) throws IOException {
+    in.defaultReadObject();
+    // If the deserialized name does not match the default value normally
+    // created at construction time, duplicate the checks
+    if (!UNKNOWN.equals(town)) {
+      performSecurityManagerCheck();
+      validateInput(town);
+    }
+  }
+}"
+JAVA,Serialization (SER),내부 클래스의 인스턴스를 직렬화하지 마십시오.,CWE-499 민감한 데이터를 포함한 직렬화 가능한 클래스,"public class OuterSer implements Serializable {
+  private int rank;
+  class InnerSer implements Serializable {
+    protected String name;
+    // ...
+  }
+}","public class OuterSer implements Serializable {
+  private int rank;
+  class InnerSer {
+    protected String name;
+    // ...
+  }
+}"
+JAVA,Serialization (SER),내부 클래스의 인스턴스를 직렬화하지 마십시오.,CWE-499 민감한 데이터를 포함한 직렬화 가능한 클래스,"public class OuterSer implements Serializable {
+  private int rank;
+  class InnerSer implements Serializable {
+    protected String name;
+    // ...
+  }
+}","public class OuterSer implements Serializable {
+  private int rank;
+  static class InnerSer implements Serializable {
+    protected String name;
+    // ...
+  }
+}"
+JAVA,Serialization (SER),역직렬화 시 private 변경 가능한 구성 요소를 방어적으로 복사하십시오.,CWE-502 신뢰할 수 없는 데이터의 역직렬화,"class MutableSer implements Serializable {
+  private static final Date epoch = new Date(0);
+  private Date date = null; // Mutable component
+   
+  public MutableSer(Date d){
+    date = new Date(d.getTime()); // Constructor performs defensive copying
+  }
+ 
+  private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+    ois.defaultReadObject();
+    // Perform validation if necessary
+  }
+}","private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+  ObjectInputStream.GetField fields = ois.readFields();
+  Date inDate = (Date) fields.get(""date"", epoch);
+  // Defensively copy the mutable component
+  date = new Date(inDate.getTime());
+  // Perform validation if necessary
+}"
+JAVA,Serialization (SER),구현에 정의된 불변 조건을 가진 클래스에 대해 기본 직렬화 형식을 사용하지 마십시오.,,"public class NumberData extends Number {
+  // ... Implement abstract Number methods, like Number.doubleValue()...
+ 
+  private static final NumberData INSTANCE = new NumberData ();
+  public static NumberData getInstance() {
+    return INSTANCE;
+  }
+ 
+  private NumberData() {
+    // Perform security checks and parameter validation
+  }
+ 
+  protected int printData() {
+    int data = 1000;
+    // Print data
+    return data;
+  }
+}
+ 
+class Malicious {
+  public static void main(String[] args) {
+    NumberData sc = (NumberData) deepCopy(NumberData.getInstance());
+    // Prints false; indicates new instance
+    System.out.println(sc == NumberData.getInstance()); 
+    System.out.println(""Balance = "" + sc.printData());
+  }
+ 
+  // This method should not be used in production code
+  public static Object deepCopy(Object obj) {
+    try {
+      ByteArrayOutputStream bos = new ByteArrayOutputStream();
+      new ObjectOutputStream(bos).writeObject(obj);
+      ByteArrayInputStream bin =
+          new ByteArrayInputStream(bos.toByteArray());
+      return new ObjectInputStream(bin).readObject();
+    } catch (Exception e) {
+      throw new IllegalArgumentException(e);
+    }
+  }
+}","public class NumberData extends Number {
+  // ...
+  protected final Object readResolve() throws NotSerializableException {
+    return INSTANCE;
+  }
+}"
+JAVA,Serialization (SER),구현에 정의된 불변 조건을 가진 클래스에 대해 기본 직렬화 형식을 사용하지 마십시오.,,"public class Lottery implements Serializable { 
+  private int ticket = 1;
+  private SecureRandom draw = new SecureRandom();
+ 
+  public Lottery(int ticket) {
+    this.ticket = (int) (Math.abs(ticket % 20000) + 1);
+  }
+ 
+  public int getTicket() {
+    return this.ticket;
+  }
+ 
+  public int roll() {
+    this.ticket = (int) ((Math.abs(draw.nextInt()) % 20000) + 1);
+    return this.ticket;
+  }
+ 
+  public static void main(String[] args) {
+    Lottery l = new Lottery(2);
+    for (int i = 0; i < 10; i++) {
+      l.roll();
+      System.out.println(l.getTicket());
+    }
+  }
+ 
+  private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+    in.defaultReadObject();
+  }
+}","public final class Lottery implements Serializable {
+  // ...
+  private synchronized void readObject(java.io.ObjectInputStream s)
+                       throws IOException, ClassNotFoundException {
+    ObjectInputStream.GetField fields = s.readFields();
+    int ticket = fields.get(""ticket"", 0);
+    if (ticket > 20000 || ticket <= 0) {
+      throw new InvalidObjectException(""Not in range!"");
+    }
+    // Validate draw
+    this.ticket = ticket;
+  }
+}"
+JAVA,Serialization (SER),구현에 정의된 불변 조건을 가진 클래스에 대해 기본 직렬화 형식을 사용하지 마십시오.,CWE-502 신뢰할 수 없는 데이터의 역직렬화,"public class AtomicReferenceArray<E> implements java.io.Serializable {
+  private static final long serialVersionUID = -6209656149925076980L;
+ 
+  // Rest of class...
+  // No readObject() method, relies on default readObject
+}","public class AtomicReferenceArray<E> implements java.io.Serializable {
+  private static final long serialVersionUID = -6209656149925076980L;
+ 
+  // Rest of class...
+ 
+  /**
+   * Reconstitutes the instance from a stream (that is, deserializes it).
+   * @param s the stream
+   */
+  private void readObject(java.io.ObjectInputStream s)
+    throws java.io.IOException, ClassNotFoundException {
+    // Note: This must be changed if any additional fields are defined
+    Object a = s.readFields().get(""array"", null);
+    if (a == null || !a.getClass().isArray())
+      throw new java.io.InvalidObjectException(""Not array type"");
+    if (a.getClass() != Object[].class)
+      a = Arrays.copyOf((Object[])a, Array.getLength(a), Object[].class);
+    unsafe.putObjectVolatile(this, arrayFieldOffset, a);
+  }
+}"
+JAVA,Serialization (SER),권한이 있는 컨텍스트에서 역직렬화하기 전에 권한을 최소화하십시오.,CWE-250 불필요한 권한으로 실행,"import java.io.*;
+import java.security.*;
+
+public class NonCompliantExample {
+    public static void main(String[] args) throws Exception {
+        // 권한이 부여된 컨텍스트에서 역직렬화 수행
+        AccessController.doPrivileged((PrivilegedExceptionAction<Void>) () -> {
+            try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(""object.dat""))) {
+                Object obj = ois.readObject();
+                // 역직렬화된 객체 사용
+            }
+            return null;
+        });
+    }
+}","import java.io.*;
+import java.security.*;
+
+public class CompliantExample {
+    public static void main(String[] args) throws Exception {
+        // 최소 권한으로 역직렬화 수행
+        AccessController.doPrivileged((PrivilegedExceptionAction<Void>) () -> {
+            // 필요한 최소 권한 설정
+            PermissionCollection minimalPermissions = new Permissions();
+            minimalPermissions.add(new File"
+JAVA,Serialization (SER),readObject() 메서드에서 재정의 가능한 메서드를 호출하지 마십시오.,,"private void readObject(final ObjectInputStream stream)
+                        throws IOException, ClassNotFoundException {
+  overridableMethod();
+  stream.defaultReadObject();
+}
+ 
+public void overridableMethod() {
+  // ...
+}","private void readObject(final ObjectInputStream stream)
+                        throws IOException, ClassNotFoundException {
+  stream.defaultReadObject();
+}"
+JAVA,Serialization (SER),직렬화 과정에서 메모리 및 자원 누수를 방지하십시오.,"CWE-400 통제되지 않은 자원 소비 (일명 ""자원 고갈""), CWE-770 제한 또는 조절 없이 자원 할당","class SensorData implements Serializable {
+  // 1 MB of data per instance!
+  ...
+  public static SensorData readSensorData() {...}
+  public static boolean isAvailable() {...}
+}
+ 
+class SerializeSensorData {
+  public static void main(String[] args) throws IOException {
+    ObjectOutputStream out = null;
+    try {
+      out = new ObjectOutputStream(
+          new BufferedOutputStream(new FileOutputStream(""ser.dat"")));
+      while (SensorData.isAvailable()) {
+        // Note that each SensorData object is 1 MB in size
+        SensorData sd = SensorData.readSensorData();
+        out.writeObject(sd);
+      }
+    } finally {
+      if (out != null) {
+        out.close();
+      }
+    }
+  }
+}","class SerializeSensorData {
+  public static void main(String[] args) throws IOException {
+    ObjectOutputStream out = null;
+    try {
+      out = new ObjectOutputStream(
+          new BufferedOutputStream(new FileOutputStream(""ser.dat"")));
+      while (SensorData.isAvailable()) {
+        // Note that each SensorData object is 1 MB in size
+        SensorData sd = SensorData.readSensorData();
+        out.writeObject(sd);
+        out.reset(); // Reset the stream
+      }
+    } finally {
+      if (out != null) {
+        out.close();
+      }
+    }
+  }
+}"
+JAVA,Serialization (SER),외부화 가능한 객체가 덮어쓰이지 않도록 방지하십시오.,,"public void readExternal(ObjectInput in)
+                         throws IOException, ClassNotFoundException {
+   // Read instance fields
+   this.name = (String) in.readObject();
+   this.UID = in.readInt();
+   // ...
+}","private final Object lock = new Object();
+private boolean initialized = false;
+ 
+public void readExternal(ObjectInput in)
+                         throws IOException, ClassNotFoundException {
+  synchronized (lock) {
+    if (!initialized) {
+      // Read instance fields
+      this.name = (String) in.readObject();
+      this.UID = in.readInt();
+      // ... 
+      initialized = true;
+    } else {
+      throw new IllegalStateException();
+    }
+  }
+}"
+JAVA,Serialization (SER),신뢰할 수 없는 데이터의 역직렬화를 방지하십시오.,CWE-502 신뢰할 수 없는 데이터의 역직렬화,"import java.io.*;
+ 
+class DeserializeExample {
+  public static Object deserialize(byte[] buffer) throws IOException, ClassNotFoundException {
+    Object ret = null;
+    try (ByteArrayInputStream bais = new ByteArrayInputStream(buffer)) {
+      try (ObjectInputStream ois = new ObjectInputStream(bais)) {
+        ret = ois.readObject();
+      }
+    }
+    return ret;
+  }
+}","import java.io.*;
+import java.util.*;
+ 
+class WhitelistedObjectInputStream extends ObjectInputStream {
+  public Set whitelist;
+ 
+  public WhitelistedObjectInputStream(InputStream inputStream, Set wl) throws IOException {
+    super(inputStream);
+    whitelist = wl;
+  }
+  
+  @Override
+  protected Class<?> resolveClass(ObjectStreamClass cls) throws IOException, ClassNotFoundException {
+    if (!whitelist.contains(cls.getName())) {
+      throw new InvalidClassException(""Unexpected serialized class"", cls.getName());
+    }
+    return super.resolveClass(cls);
+  }
+}
+  
+class DeserializeExample {
+  private static Object deserialize(byte[] buffer) throws IOException, ClassNotFoundException {
+    Object ret = null;
+    Set whitelist = new HashSet<String>(Arrays.asList(new String[]{""GoodClass1"",""GoodClass2""}));
+    try (ByteArrayInputStream bais = new ByteArrayInputStream(buffer)) {
+      try (WhitelistedObjectInputStream ois = new WhitelistedObjectInputStream(bais, whitelist)) {
+        ret = ois.readObject();
+      }
+    }
+    return ret;
+  }
+}"
+JAVA,Platform Security (SEC),권한이 부여된 블록이 신뢰 경계를 넘어 민감한 정보를 누출하지 않도록 하십시오.,"CWE-266 부적절한 권한 할당, CWE-272 최소 권한 위반","public class PasswordManager {
+
+    public static void changePassword() throws FileNotFoundException {
+        FileInputStream fin = openPasswordFile();
+        // 기존 비밀번호 확인 및 변경 로직
+    }
+
+    public static FileInputStream openPasswordFile() throws FileNotFoundException {
+        final String passwordFile = ""password"";
+        FileInputStream fin = null;
+        try {
+            fin = AccessController.doPrivileged(
+                new PrivilegedExceptionAction<FileInputStream>() {
+                    public FileInputStream run() throws FileNotFoundException {
+                        // 민감한 파일에 접근
+                        return new FileInputStream(passwordFile);
+                    }
+                }
+            );
+        } catch (PrivilegedActionException e) {
+            throw (FileNotFoundException) e.getException();
+        }
+        return fin;
+    }
+}","public class PasswordManager {
+
+    public static void changePassword() throws FileNotFoundException {
+        // 비밀번호 변경 로직
+        try (FileInputStream fin = openPasswordFile()) {
+            // 기존 비밀번호 확인 및 변경 로직
+        } catch (IOException e) {
+            // 예외 처리
+        }
+    }
+
+    private static FileInputStream openPasswordFile() throws FileNotFoundException {
+        final String passwordFile = ""password"";
+        try {
+            return AccessController.doPrivileged(
+                new PrivilegedExceptionAction<FileInputStream>() {
+                    public FileInputStream run() throws FileNotFoundException {
+                        // 민감한 파일에 접근
+                        return new FileInputStream(passwordFile);
+                    }
+                }
+            );
+        } catch (PrivilegedActionException e) {
+            throw (FileNotFoundException) e.getException();
+        }
+    }
+}"
+JAVA,Platform Security (SEC),권한 블록에서 오염된 변수를 허용하지 않습니다.,"CWE-266 부적절한 권한 할당, CWE-272 최소 권한 위반, CWE-732 중요한 리소스에 대한 부적절한 권한 할당","private void privilegedMethod(final String filename) throws FileNotFoundException {
+    try {
+        FileInputStream fis = AccessController.doPrivileged(
+            new PrivilegedExceptionAction<FileInputStream>() {
+                public FileInputStream run() throws FileNotFoundException {
+                    return new FileInputStream(filename);
+                }
+            }
+        );
+        // 파일을 사용한 후 닫기
+    } catch (PrivilegedActionException e) {
+        // 예외 처리
+    }
+}","private void privilegedMethod(final String filename) throws FileNotFoundException {
+    final String cleanFilename;
+    try {
+        cleanFilename = cleanAFilenameAndPath(filename);
+    } catch (Exception e) {
+        // cleanAFilenameAndPath 메서드의 사양에 따른 예외 처리
+        return;
+    }
+    try {
+        FileInputStream fis = AccessController.doPrivileged(
+            new PrivilegedExceptionAction<FileInputStream>() {
+                public FileInputStream run() throws FileNotFoundException {
+                    return new FileInputStream(cleanFilename);
+                }
+            }
+        );
+        // 파일을 사용한 후 닫기
+    } catch (PrivilegedActionException e) {
+        // 예외 처리
+    }
+}"
+JAVA,Platform Security (SEC),권한 블록에서 오염된 변수를 허용하지 않습니다.,"CWE-266 부적절한 권한 할당, CWE-272 최소 권한 위반, CWE-732 중요한 리소스에 대한 부적절한 권한 할당","private void privilegedMethod(final String filename) throws FileNotFoundException {
+    try {
+        FileInputStream fis = AccessController.doPrivileged(
+            new PrivilegedExceptionAction<FileInputStream>() {
+                public FileInputStream run() throws FileNotFoundException {
+                    return new FileInputStream(filename);
+                }
+            }
+        );
+        // 파일을 사용한 후 닫기
+    } catch (PrivilegedActionException e) {
+        // 예외 처리
+    }
+}","private void privilegedMethod() throws FileNotFoundException {
+    final String trustedFilename = ""/path/to/trusted/file"";
+    try {
+        FileInputStream fis = AccessController.doPrivileged(
+            new PrivilegedExceptionAction<FileInputStream>() {
+                public FileInputStream run() throws FileNotFoundException {
+                    return new FileInputStream(trustedFilename);
+                }
+            }
+        );
+        // 파일을 사용한 후 닫기
+    } catch (PrivilegedActionException e) {
+        // 예외 처리
+    }
+}"
+JAVA,Platform Security (SEC),신뢰할 수 없는 코드가 임의의 클래스를 로드하도록 허용한 후 신뢰할 수 있는 클래스를 로드하지 마십시오.,,"public class NonCompliantExample {
+    public static void main(String[] args) {
+        // 신뢰할 수 없는 코드가 임의의 클래스를 로드하도록 허용
+        UntrustedClassLoader untrustedLoader = new UntrustedClassLoader();
+        untrustedLoader.loadClass(""com.example.TrustedClass"");
+
+        // 이후에 신뢰할 수 있는 클래스 로드
+        Class.forName(""com.example.TrustedClass"");
+    }
+}","public class CompliantExample {
+    public static void main(String[] args) {
+        // 신뢰할 수 있는 클래스 먼저 로드
+        Class.forName(""com.example.TrustedClass"");
+
+        // 이후에 신뢰할 수 없는 코드가 임의의 클래스를 로드하도록 허용
+        UntrustedClassLoader untrustedLoader = new UntrustedClassLoader();
+        untrustedLoader.loadClass(""com.example.UntrustedClass"");
+    }
+}"
+JAVA,Platform Security (SEC),"리플렉션을 사용하여 클래스, 메서드 또는 필드의 접근성을 높이지 마라",,"import java.lang.reflect.Field;
+
+public class FieldExample {
+    private int i = 3;
+    private int j = 4;
+
+    public void zeroField(String fieldName) {
+        try {
+            Field field = this.getClass().getDeclaredField(fieldName);
+            field.setAccessible(true); // 접근성 증가
+            field.setInt(this, 0);
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            // 예외 처리
+        }
+    }
+
+    @Override
+    public String toString() {
+        return ""FieldExample: i="" + i + "", j="" + j;
+    }
+
+    public static void main(String[] args) {
+        FieldExample fe = new FieldExample();
+        System.out.println(fe);
+        fe.zeroField(""i"");
+        System.out.println(fe);
+    }
+}","public class FieldExample {
+    private int i = 3;
+    private int j = 4;
+
+    public void zeroI() {
+        this.i = 0;
+    }
+
+    public void zeroJ() {
+        this.j = 0;
+    }
+
+    @Override
+    public String toString() {
+        return ""FieldExample: i="" + i + "", j="" + j;
+    }
+
+    public static void main(String[] args) {
+        FieldExample fe = new FieldExample();
+        System.out.println(fe);
+        fe.zeroI();
+        System.out.println(fe);
+    }
+}"
+JAVA,Platform Security (SEC),신뢰할 수 없는 소스를 기반으로 보안 검사를 수행하지 마세요.,"CWE-302 가정된 불변 데이터를 통한 인증 우회, CWE-470 외부에서 제어되는 입력을 사용하여 클래스나 코드를 선택 (""안전하지 않은 리플렉션"")","public RandomAccessFile openFile(final java.io.File f) {
+  askUserPermission(f.getPath());
+  // ...
+  return (RandomAccessFile) AccessController.doPrivileged(new PrivilegedAction<Object>() {
+    public Object run() {
+      return new RandomAccessFile(f, f.getPath());
+    }
+  });
+}","public RandomAccessFile openFile(java.io.File f) {
+  final java.io.File copy = new java.io.File(f.getPath());
+  askUserPermission(copy.getPath());
+  // ...
+  return (RandomAccessFile) AccessController.doPrivileged(new PrivilegedAction<Object>() {
+    public Object run() {
+      return new RandomAccessFile(copy, copy.getPath());
+    }
+  });
+}"
+JAVA,Platform Security (SEC),보안 관리자 점검으로 민감한 작업 보호,,"class SensitiveHash {
+  private Hashtable<Integer,String> ht = new Hashtable<Integer,String>();
+ 
+  public void removeEntry(Object key) {
+    ht.remove(key);
+  }
+}","class SensitiveHash {
+  private Hashtable<Integer,String> ht = new Hashtable<Integer,String>();
+ 
+  public void removeEntry(Object key) {
+    check(""removeKeyPermission"");
+    ht.remove(key);
+  }
+ 
+  private void check(String directive) {
+    SecurityManager sm = System.getSecurityManager();
+    if (sm != null) {
+      sm.checkSecurityAccess(directive);
+    }
+  }
+}"
+JAVA,Platform Security (SEC),보안 관리자 점검으로 민감한 작업 보호,,"SecurityManager sm = System.getSecurityManager();
+ 
+if (sm != null) {  // Check whether file may be read
+  sm.checkRead(""/local/schema.dtd"");
+}","SecurityManager sm = System.getSecurityManager();
+ 
+if (sm != null) {  // Check whether file may be read
+  DTDPermission perm = new DTDPermission(""/local/"",  ""readDTD"");
+  sm.checkPermission(perm);
+}"
+JAVA,Platform Security (SEC),보안 관리자 점검으로 민감한 작업 보호,,"SecurityManager sm = System.getSecurityManager();
+ 
+if (sm != null) {  // Check whether file may be read
+  sm.checkRead(""/local/schema.dtd"");
+}","// Take the snapshot of the required context, store in acc, and pass it to another context
+AccessControlContext acc = AccessController.getContext();
+ 
+// Accept acc in another context and invoke checkPermission() on it
+acc.checkPermission(perm);"
+JAVA,Platform Security (SEC),URLClassLoader와 java.util.jar에서 제공하는 기본 자동 서명 검증에 의존하지 마라,"CWE-300 비종단점에 의해 접근 가능한 채널 (일명 ""중간자 공격, Man-in-the-Middle""), CWE-319 민감한 정보의 평문 전송, CWE-347 암호화 서명의 부적절한 검증, CWE-494 무결성 확인 없이 코드 다운로드","import java.net.URL;
+import java.net.URLClassLoader;
+
+public class JarRunner {
+    public static void main(String[] args) throws Exception {
+        URL url = new URL(args[0]);
+        URLClassLoader loader = new URLClassLoader(new URL[]{url});
+        String className = args[1];
+        Class<?> cls = loader.loadClass(className);
+        cls.getMethod(""main"", String[].class).invoke(null, (Object) new String[]{});
+    }
+}","import java.io.File;
+import java.io.FileInputStream;
+import java.security.KeyStore;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateFactory;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.JarInputStream;
+
+public class SecureJarLoader {
+    public static void main(String[] args) throws Exception {
+        String jarPath = args[0];
+        String certPath = args[1];
+
+        // 신뢰할 수 있는 인증서 로드
+        CertificateFactory cf = CertificateFactory.getInstance(""X.509"");
+        Certificate trustedCert;
+        try (FileInputStream fis = new FileInputStream(certPath)) {
+            trustedCert = cf.generateCertificate(fis);
+        }
+
+        // JAR 파일의 서명 검증
+        try (JarFile jarFile = new JarFile(jarPath, true)) {
+            jarFile.stream().forEach(entry -> {
+                try {
+                    if (entry.isDirectory()) return;
+                    Certificate[] certs = getCertificates(jarFile, entry);
+                    if (certs != null) {
+                        for (Certificate cert : certs) {
+                            if (cert.equals(trustedCert)) {
+                                // 신뢰할 수 있는 인증서로 서명된 항목
+                                return;
+                            }
+                        }
+                    }
+                    throw new SecurityException(""서명 검증 실패: "" + entry.getName());
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            });
+        }
+
+        // 서명 검증이 완료된 JAR 파일 로드 및 실행
+        URL url = new File(jarPath).toURI().toURL();
+        try (URLClassLoader loader = new URLClassLoader(new URL[]{url})) {
+            String className = args[2];
+            Class<?> cls = loader.loadClass(className);
+            cls.getMethod(""main"", String[].class).invoke(null, (Object) new String[]{});
+        }
+    }
+
+    private static Certificate[] getCertificates(JarFile jarFile, JarEntry entry) throws Exception {
+        try (JarInputStream jis = new JarInputStream(jarFile.getInputStream(entry))) {
+            while (jis.getNextEntry() != null) {
+                // 모든 항목을 읽어야 서명 검증이 완료됨
+            }
+            return entry.getCertificates();
+        }
+    }
+}"
+JAVA,Platform Security (SEC),사용자 정의 클래스 로더를 작성할 때 슈퍼클래스의 getPermissions() 메서드를 호출합니다.,,"protected PermissionCollection getPermissions(CodeSource cs) {
+  PermissionCollection pc = new Permissions();
+  // Allow exit from the VM anytime
+  pc.add(new RuntimePermission(""exitVM""));
+  return pc;
+}","protected PermissionCollection getPermissions(CodeSource cs) {
+  PermissionCollection pc = super.getPermissions(cs);
+  // Allow exit from the VM anytime
+  pc.add(new RuntimePermission(""exitVM""));
+  return pc;
+}"
+JAVA,Runtime Environment (ENV),모든 보안에 민감한 코드를 하나의 JAR에 넣고 서명 및 봉인하세요.,CWE-349 신뢰할 수 있는 데이터와 함께 불필요한 신뢰할 수 없는 데이터를 수용,"package trusted;
+import untrusted.RetValue;
+ 
+public class MixMatch {
+  private void privilegedMethod() throws IOException {
+    try {
+      AccessController.doPrivileged(
+        new PrivilegedExceptionAction<Void>() {
+          public Void run() throws IOException, FileNotFoundException {
+            final FileInputStream fis = new FileInputStream(""file.txt"");
+            try {
+              RetValue rt = new RetValue();
+ 
+              if (rt.getValue() == 1) {
+                // Do something with sensitive file
+              }
+            } finally {
+              fis.close();
+            }
+            return null; // Nothing to return
+          }
+        }
+      );
+    } catch (PrivilegedActionException e) {
+      // Forward to handler and log
+    }
+  }
+ 
+  public static void main(String[] args) throws IOException {
+    MixMatch mm = new MixMatch();
+    mm.privilegedMethod();
+  }
+}
+ 
+// In another JAR file:
+package untrusted;
+ 
+class RetValue {
+  public int getValue() {
+    return 1;
+  }
+}","package trusted;
+ 
+public class MixMatch {
+  // ...
+}
+ 
+ 
+// In the same signed & sealed JAR file:
+package trusted;
+ 
+class RetValue {
+  int getValue() {
+    return 1;
+  }
+}"
+JAVA,Runtime Environment (ENV),모든 보안에 민감한 코드를 하나의 JAR에 넣고 서명 및 봉인하세요.,CWE-349 신뢰할 수 있는 데이터와 함께 불필요한 신뢰할 수 없는 데이터를 수용,"package trusted;
+import untrusted.RetValue;
+ 
+public class MixMatch {
+  private void privilegedMethod() throws IOException {
+    try {
+      final FileInputStream fis = AccessController.doPrivileged(
+        new PrivilegedExceptionAction<FileInputStream>() {
+          public FileInputStream run() throws FileNotFoundException {
+            return new FileInputStream(""file.txt"");
+          }
+        }
+      );
+      try {
+        RetValue rt = new RetValue();
+ 
+        if (rt.getValue() == 1) {
+          // Do something with sensitive file
+        }
+      } finally {
+        fis.close();
+      }
+    } catch (PrivilegedActionException e) {
+      // Forward to handler and log
+    }
+  }
+ 
+  public static void main(String[] args) throws IOException {
+    MixMatch mm = new MixMatch();
+    mm.privilegedMethod();
+  }
+}
+ 
+// In another JAR file:
+package untrusted;
+ 
+class RetValue {
+  public int getValue() {
+    return 1;
+  }
+}","package trusted;
+ 
+public class MixMatch {
+  // ...
+}
+ 
+ 
+// In the same signed & sealed JAR file:
+package trusted;
+ 
+class RetValue {
+  int getValue() {
+    return 1;
+  }
+}"
+JAVA,Runtime Environment (ENV),환경 변수의 값을 신뢰하지 마라,,"String username = System.getenv(""USER"");","String username = System.getProperty(""user.name"");"
+JAVA,Runtime Environment (ENV),위험한 권한 조합을 부여하지 마라,CWE-732 중요한 리소스에 대한 부적절한 권한 할당,"// 보안 정책 파일의 내용
+grant codeBase ""file:${klib.home}/j2se/home/klib.jar"" {
+    permission java.security.AllPermission;
+};","// 보안 정책 파일의 내용
+grant codeBase ""file:${klib.home}/j2se/home/klib.jar"", signedBy ""Admin"" {
+    permission java.io.FilePermission ""/tmp/*"", ""read"";
+    permission java.net.SocketPermission ""*"", ""connect"";
+};"
+JAVA,Runtime Environment (ENV),바이트코드 확인을 비활성화하지 마세요.,,java -Xverify:none ApplicationName,java -Xverify:all ApplicationName
+JAVA,Runtime Environment (ENV),원격으로 모니터링할 수 있는 애플리케이션을 배포하지 마라,,"// JVM 옵션에 원격 모니터링을 활성화하는 설정
+-Dcom.sun.management.jmxremote
+-Dcom.sun.management.jmxremote.port=12345
+-Dcom.sun.management.jmxremote.authenticate=false
+-Dcom.sun.management.jmxremote.ssl=false","// 원격 모니터링을 비활성화한 JVM 옵션
+// (특별한 설정이 없으면 원격 모니터링은 기본적으로 비활성화되어 있습니다.)"
+JAVA,Runtime Environment (ENV),프로덕션 코드에는 디버깅 진입점을 포함하지 마라,,"class Stuff {
+    private static final boolean DEBUG = false;
+    // 기타 필드와 메서드
+
+    public static void main(String[] args) {
+        Stuff.DEBUG = true;
+        Stuff stuff = new Stuff();
+        // 테스트 코드
+    }
+}","class Stuff {
+    // 기타 필드와 메서드
+}"
+JAVA,Java Native Interface (JNI),네이티브 메서드에 래퍼 정의,CWE-111 안전하지 않은 JNI의 직접 사용,"public final class NativeMethod {
+ 
+  // Public native method
+  public native void nativeOperation(byte[] data, int offset, int len);
+ 
+  // Wrapper method that lacks security checks and input validation
+  public void doOperation(byte[] data, int offset, int len) {
+    nativeOperation(data, offset, len);
+  }
+   
+  static {
+    // Load native library in static initializer of class
+    System.loadLibrary(""NativeMethodLib"");
+  }
+}","public final class NativeMethodWrapper {
+ 
+  // Private native method
+  private native void nativeOperation(byte[] data, int offset, int len);
+ 
+  // Wrapper method performs SecurityManager and input validation checks
+  public void doOperation(byte[] data, int offset, int len) {
+    // Permission needed to invoke native method
+    securityManagerCheck();
+ 
+    if (data == null) {
+      throw new NullPointerException();
+    }
+ 
+    // Copy mutable input
+    data = data.clone();
+ 
+    // Validate input
+    if ((offset < 0) || (len < 0) || (offset > (data.length - len))) {
+      throw new IllegalArgumentException();
+    }
+ 
+    nativeOperation(data, offset, len);
+  }
+ 
+  static {
+    // Load native library in static initializer of class
+    System.loadLibrary(""NativeMethodLib"");
+  }
+}"
+JAVA,Java Native Interface (JNI),즉시 호출자의 클래스 로더 인스턴스를 사용하여 작업을 수행하는 표준 API(loadLibrary)를 안전하게 호출하십시오.,CWE-111 안전하지 않은 JNI의 직접 사용,"// Trusted.java
+ 
+import java.security.*;
+ 
+public class Trusted {
+ 
+   public static void loadLibrary(final String library){
+      AccessController.doPrivileged(new PrivilegedAction<Void>() {
+         public Void run() {
+             System.loadLibrary(library);
+             return null;
+         }
+      });
+   }
+}
+ 
+---------------------------------------------------------------------------------
+ 
+// Untrusted.java
+ 
+public class Untrusted {
+ 
+   private native void nativeOperation();
+ 
+   public static void main(String[] args) {
+      String library = new String(""NativeMethodLib"");
+      Trusted.loadLibrary(library);
+      new Untrusted.nativeOperation();  // invoke the native method
+   }
+}","// Trusted.java
+ 
+import java.security.*;
+ 
+public class Trusted {
+ 
+   // load native libraries
+   static{
+      System.loadLibrary(""NativeMethodLib1"");
+      System.loadLibrary(""NativeMethodLib2"");
+      ...
+   }
+ 
+   // private native methods
+   private native void nativeOperation1(byte[] data, int offset, int len);
+   private native void nativeOperation2(...)
+   ...
+  
+   // wrapper methods perform SecurityManager and input validation checks
+   public void doOperation1(byte[] data, int offset, int len) {
+      // permission needed to invoke native method
+      securityManagerCheck();
+ 
+      if (data == null) {
+         throw new NullPointerException();
+      }
+ 
+      // copy mutable input
+      data = data.clone();
+ 
+      // validate input
+      if ((offset < 0) || (len < 0) || (offset > (data.length - len))) {
+         throw new IllegalArgumentException();
+      }
+ 
+      nativeOperation1(data, offset, len);
+   }
+    
+   public void doOperation2(...){
+      ...
+   }
+}"
+JAVA,기타,보안 데이터 교환을 위해 Socket 대신 SSLSocket을 사용하십시오.,CWE-311 민감한 데이터 암호화 실패,"// Exception handling has been omitted for the sake of brevity
+class EchoServer {
+  public static void main(String[] args) throws IOException {
+    ServerSocket serverSocket = null;
+    try {
+      serverSocket = new ServerSocket(9999);
+      Socket socket = serverSocket.accept();
+      PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
+      BufferedReader in = new BufferedReader(
+          new InputStreamReader(socket.getInputStream()));
+      String inputLine;
+      while ((inputLine = in.readLine()) != null) {
+        System.out.println(inputLine);
+        out.println(inputLine);
+      }
+    } finally {
+      if (serverSocket != null) {
+        try {
+          serverSocket.close();
+        } catch (IOException x) {
+          // Handle error
+        }
+      }
+    }
+  }
+}
+ 
+class EchoClient {
+  public static void main(String[] args)
+                          throws UnknownHostException, IOException {
+    Socket socket = null;
+    try {
+      socket = new Socket(""localhost"", 9999);
+      PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
+      BufferedReader in = new BufferedReader(
+          new InputStreamReader(socket.getInputStream()));
+      BufferedReader stdIn = new BufferedReader(
+          new InputStreamReader(System.in));
+      String userInput;
+      while ((userInput = stdIn.readLine()) != null) {
+        out.println(userInput);
+        System.out.println(in.readLine());
+      }
+    } finally {
+      if (socket != null) {
+        try {
+          socket.close();
+        } catch (IOException x) {
+          // Handle error
+        }
+      }
+    }
+  }
+}","// Exception handling has been omitted for the sake of brevity
+class EchoServer {
+  public static void main(String[] args) throws IOException {
+    SSLServerSocket sslServerSocket = null;
+    try {
+      SSLServerSocketFactory sslServerSocketFactory =
+          (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
+      sslServerSocket = (SSLServerSocket) sslServerSocketFactory.
+                        createServerSocket(9999);
+      SSLSocket sslSocket = (SSLSocket) sslServerSocket.accept();
+      PrintWriter out = new PrintWriter(sslSocket.getOutputStream(),true);
+      BufferedReader in = new BufferedReader(
+          new InputStreamReader(sslSocket.getInputStream()));
+      String inputLine;
+      while ((inputLine = in.readLine()) != null) {
+        System.out.println(inputLine);
+        out.println(inputLine);
+      }
+    } finally {
+      if (sslServerSocket != null) {
+        try {
+          sslServerSocket.close();
+        } catch (IOException x) {
+          // Handle error
+        }
+      }
+    }
+  }
+}
+ 
+class EchoClient {
+  public static void main(String[] args) throws IOException {
+    SSLSocket sslSocket = null;
+    try {
+      SSLSocketFactory sslSocketFactory =
+          (SSLSocketFactory) SSLSocketFactory.getDefault();
+      sslSocket =
+          (SSLSocket) sslSocketFactory.createSocket(""localhost"", 9999);
+      PrintWriter out = new PrintWriter(sslSocket.getOutputStream(), true);
+      BufferedReader in = new BufferedReader(
+          new InputStreamReader(sslSocket.getInputStream()));
+      BufferedReader stdIn = new BufferedReader(
+          new InputStreamReader(System.in));
+      String userInput;
+      while ((userInput = stdIn.readLine()) != null) {
+        out.println(userInput);
+        System.out.println(in.readLine());
+      }
+    } finally {
+      if (sslSocket != null) {
+        try {
+          sslSocket.close();
+        } catch (IOException x) {
+          // Handle error
+        }
+      }
+    }
+  }
+}"
+JAVA,기타,빈(공백) 무한 루프를 사용하지 마십시오.,,"public int nop() {
+  while (true) {}
+}","public final int DURATION=10000; // In milliseconds
+ 
+public void nop() throws InterruptedException {
+  while (true) {
+    // Useful operations
+    Thread.sleep(DURATION);
+  }
+}"
+JAVA,기타,빈(공백) 무한 루프를 사용하지 마십시오.,,"public int nop() {
+  while (true) {}
+}","public void nop() {
+  while (true) {
+    Thread.yield();
+  }
+}"
+JAVA,기타,강력한 난수를 생성하라,"CWE-327 손상되었거나 위험한 암호화 알고리즘의 사용  
+CWE-330 충분히 랜덤하지 않은 값의 사용  
+CWE-332 PRNG에서의 불충분한 엔트로피  
+CWE-336 PRNG에서 동일한 시드 사용  
+CWE-337 예측 가능한 시드의 사용 in PRNG","import java.util.Random;
+
+public class WeakRandomExample {
+    public static void main(String[] args) {
+        Random random = new Random(123L); // 고정된 시드 값 사용
+        for (int i = 0; i < 20; i++) {
+            int n = random.nextInt(21); // 0부터 20까지의 정수 생성
+            System.out.println(n);
+        }
+    }
+}","import java.security.SecureRandom;
+
+public class StrongRandomExample {
+    public static void main(String[] args) {
+        SecureRandom secureRandom = new SecureRandom();
+        for (int i = 0; i < 20; i++) {
+            int n = secureRandom.nextInt(21); // 0부터 20까지의 정수 생성
+            System.out.println(n);
+        }
+    }
+}"
+JAVA,기타,강력한 난수를 생성하라,"CWE-327 손상되었거나 위험한 암호화 알고리즘의 사용  
+CWE-330 충분히 랜덤하지 않은 값의 사용  
+CWE-332 PRNG에서의 불충분한 엔트로피  
+CWE-336 PRNG에서 동일한 시드 사용  
+CWE-337 예측 가능한 시드의 사용 in PRNG","import java.util.Random;
+
+public class WeakRandomExample {
+    public static void main(String[] args) {
+        Random random = new Random(123L); // 고정된 시드 값 사용
+        for (int i = 0; i < 20; i++) {
+            int n = random.nextInt(21); // 0부터 20까지의 정수 생성
+            System.out.println(n);
+        }
+    }
+}","// Java 8 이상에서의 준수 코드 예시
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+
+public class StrongRandomExample {
+    public static void main(String[] args) {
+        try {
+            SecureRandom secureRandom = SecureRandom.getInstanceStrong();
+            for (int i = 0; i < 20; i++) {
+                int n = secureRandom.nextInt(21); // 0부터 20까지의 정수 생성
+                System.out.println(n);
+            }
+        } catch (NoSuchAlgorithmException e) {
+            // 예외 처리 로직
+        }
+    }
+}"
+JAVA,기타,민감한 정보를 하드코딩하지 마라,"CWE-259 하드코드된 비밀번호 사용  
+CWE-798 하드코드된 자격 증명 사용","class DatabaseConfig {
+    private static final String DB_USERNAME = ""admin"";
+    private static final String DB_PASSWORD = ""password123"";
+    // 기타 코드
+}","import java.io.Console;
+
+class DatabaseConfig {
+    public static void main(String[] args) {
+        Console console = System.console();
+        if (console == null) {
+            throw new IllegalStateException(""콘솔을 사용할 수 없습니다."");
+        }
+        String username = console.readLine(""사용자 이름: "");
+        char[] password = console.readPassword(""비밀번호: "");
+        // 입력받은 사용자 이름과 비밀번호를 사용하여 데이터베이스 연결
+    }
+}"
+JAVA,기타,메모리 누수 방지,"CWE-401 마지막 참조를 제거하기 전에 메모리를 부적절하게 해제 (""메모리 누수"")","public class Leak {
+    static Vector<String> vector = new Vector<>();
+
+    public void useVector(int count) {
+        for (int n = 0; n < count; n++) {
+            vector.add(Integer.toString(n));
+        }
+        // ...
+        for (int n = count - 1; n > 0; n--) { // 메모리 해제
+            vector.removeElementAt(n);
+        }
+    }
+
+    public static void main(String[] args) {
+        Leak le = new Leak();
+        int i = 1;
+        while (true) {
+            System.out.println(""Iteration: "" + i);
+            le.useVector(1);
+            i++;
+        }
+    }
+}","public class Leak {
+    static Vector<String> vector = new Vector<>();
+
+    public void useVector(int count) {
+        int n = 0;
+        try {
+            for (; n < count; n++) {
+                vector.add(Integer.toString(n));
+            }
+            // ...
+        } finally {
+            for (n = n - 1; n >= 0; n--) {
+                vector.removeElementAt(n);
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        Leak le = new Leak();
+        int i = 1;
+        while (true) {
+            System.out.println(""Iteration: "" + i);
+            le.useVector(1);
+            i++;
+        }
+    }
+}"
+JAVA,기타,힙 공간을 소진하지 마십시오.,"CWE-400 통제되지 않은 자원 소비 (일명 ""자원 고갈""), CWE-770 제한 또는 조절 없이 자원 할당","class ReadNames {
+  private Vector<String> names = new Vector<String>();
+  private final InputStreamReader input;
+  private final BufferedReader reader;
+ 
+  public ReadNames(String filename) throws IOException {
+    this.input = new FileReader(filename);
+    this.reader = new BufferedReader(input);
+  }
+ 
+  public void addNames() throws IOException {
+    try {
+      String newName;
+      while (((newName = reader.readLine()) != null) &&
+             !(newName.equalsIgnoreCase(""quit""))) {
+        names.addElement(newName);
+        System.out.println(""adding "" + newName);
+      }
+    } finally {
+      input.close();
+    }
+  }
+ 
+  public static void main(String[] args) throws IOException {
+    if (args.length != 1) {
+      System.out.println(""Arguments: [filename]"");
+      return;
+    }
+    ReadNames demo = new ReadNames(args[0]);
+    demo.addNames();
+  }
+}","class ReadNames {
+  // ... Other methods and variables
+ 
+  public static final int fileSizeLimit = 1000000;
+ 
+  public ReadNames(String filename) throws IOException {
+    long size = Files.size( Paths.get( filename));
+    if (size > fileSizeLimit) {
+      throw new IOException(""File too large"");
+    } else if (size == 0L) {
+      throw new IOException(""File size cannot be determined, possibly too large"");
+    }
+    this.input = new FileReader(filename);
+    this.reader = new BufferedReader(input);
+  }
+}"
+JAVA,기타,힙 공간을 소진하지 마십시오.,"CWE-400 통제되지 않은 자원 소비 (일명 ""자원 고갈""), CWE-770 제한 또는 조절 없이 자원 할당","class ReadNames {
+  private Vector<String> names = new Vector<String>();
+  private final InputStreamReader input;
+  private final BufferedReader reader;
+ 
+  public ReadNames(String filename) throws IOException {
+    this.input = new FileReader(filename);
+    this.reader = new BufferedReader(input);
+  }
+ 
+  public void addNames() throws IOException {
+    try {
+      String newName;
+      while (((newName = reader.readLine()) != null) &&
+             !(newName.equalsIgnoreCase(""quit""))) {
+        names.addElement(newName);
+        System.out.println(""adding "" + newName);
+      }
+    } finally {
+      input.close();
+    }
+  }
+ 
+  public static void main(String[] args) throws IOException {
+    if (args.length != 1) {
+      System.out.println(""Arguments: [filename]"");
+      return;
+    }
+    ReadNames demo = new ReadNames(args[0]);
+    demo.addNames();
+  }
+}","class ReadNames {
+  // ... Other methods and variables
+ 
+  public static String readLimitedLine(Reader reader, int limit)
+                                       throws IOException {
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < limit; i++) {
+      int c = reader.read();
+      if (c == -1) {
+        return ((sb.length() > 0) ? sb.toString() : null);
+      }
+      if (((char) c == '\n') || ((char) c == '\r')) {
+        break;
+      }
+      sb.append((char) c);
+    }
+    return sb.toString();
+  }
+ 
+  public static final int lineLengthLimit = 1024;
+  public static final int lineCountLimit = 1000000;
+ 
+  public void addNames() throws IOException {
+    try {
+      String newName;
+      for (int i = 0; i < lineCountLimit; i++) {
+        newName = readLimitedLine(reader, lineLengthLimit);
+        if (newName == null || newName.equalsIgnoreCase(""quit"")) {
+          break;
+        }
+        names.addElement(newName);
+        System.out.println(""adding "" + newName);
+      }
+    } finally {
+      input.close();
+    }
+  }
+ 
+}"
+JAVA,기타,힙 공간을 소진하지 마십시오.,"CWE-400 통제되지 않은 자원 소비 (일명 ""자원 고갈""), CWE-770 제한 또는 조절 없이 자원 할당","/* Assuming the heap size as 512 MB
+ * (calculated as 1/4 of 2GB RAM = 512MB)
+ * Considering long values being entered (64 bits each,
+ * the max number of elements would be 512MB/64 bits =
+ * 67108864)
+ */
+public class ReadNames {
+  // Accepts unknown number of records
+  Vector<Long> names = new Vector<Long>();
+  long newID = 0L;
+  int count = 67108865;
+  int i = 0;
+  InputStreamReader input = new InputStreamReader(System.in);
+  Scanner reader = new Scanner(input);
+ 
+  public void addNames() {
+    try {
+      do {
+        // Adding unknown number of records to a list
+        // The user can enter more IDs than the heap can support and,
+        // as a result, exhaust the heap. Assume that the record ID
+        // is a 64-bit long value
+        System.out.print(""Enter recordID (To quit, enter -1): "");
+        newID = reader.nextLong();
+ 
+        names.addElement(newID);
+        i++;
+      } while (i < count || newID != -1);
+    } finally {
+      input.close();
+    }
+  }
+ 
+  public static void main(String[] args) {
+    ReadNames demo = new ReadNames();
+    demo.addNames();
+  }
+}","// ...
+int count = 10000000;
+// …"
+JAVA,기타,반복이 진행 중일 때는 기본 컬렉션을 수정하지 마세요.,,"class BadIterate {
+  public static void main(String[] args) {
+    List<String> list = new ArrayList<String>();
+    list.add(""one"");
+    list.add(""two"");
+         
+    Iterator iter = list.iterator();
+    while (iter.hasNext()) {
+      String s = (String)iter.next();
+      if (s.equals(""one"")) {
+        list.remove(s);
+      }
+    }
+  }   
+}","// ...
+if (s.equals(""one"")) {
+  iter.remove();
+}
+// …"
+JAVA,기타,반복이 진행 중일 때는 기본 컬렉션을 수정하지 마세요.,,"List<Widget> widgetList = new ArrayList<Widget>();
+ 
+public void widgetOperation() {
+  // May throw ConcurrentModificationException
+  for (Widget w : widgetList) {
+    doSomething(w);
+  }
+}","List<Widget> widgetList =
+    Collections.synchronizedList(new ArrayList<Widget>());
+ 
+public void widgetOperation() {
+  synchronized (widgetList) { // Client-side locking
+    for (Widget w : widgetList) {
+      doSomething(w);
+    }
+  }
+}"
+JAVA,기타,반복이 진행 중일 때는 기본 컬렉션을 수정하지 마세요.,,"List<Widget> widgetList = new ArrayList<Widget>();
+ 
+public void widgetOperation() {
+  // May throw ConcurrentModificationException
+  for (Widget w : widgetList) {
+    doSomething(w);
+  }
+}","List<Widget> widgetList = new ArrayList<Widget>();
+ 
+public void widgetOperation() {
+  List<Widget> deepCopy = new ArrayList<Widget>();
+  synchronized (widgetList) { // Client-side locking
+    for (Object obj : widgetList) {
+      deepCopy.add(obj.clone());
+    }
+  }
+ 
+  for (Widget w : deepCopy) {
+    doSomething(w);
+  }
+}"
+JAVA,기타,반복이 진행 중일 때는 기본 컬렉션을 수정하지 마세요.,,"List<Widget> widgetList = new ArrayList<Widget>();
+ 
+public void widgetOperation() {
+  // May throw ConcurrentModificationException
+  for (Widget w : widgetList) {
+    doSomething(w);
+  }
+}","List<Widget> widgetList = new CopyOnWriteArrayList<Widget>();
+ 
+public void widgetOperation() {
+  for (Widget w : widgetList) {
+    doSomething(w);
+  }
+}"
+JAVA,기타,싱글톤 객체의 다중 인스턴스화 방지,"CWE-543, 멀티스레드 컨텍스트에서 동기화 없이 싱글톤 패턴 사용","class MySingleton {
+  private static MySingleton instance;
+ 
+  protected MySingleton() {   
+    instance = new MySingleton();
+  }
+ 
+  public static MySingleton getInstance() {   
+    return instance;
+  }
+}","class MySingleton {
+  private static final MySingleton instance = new MySingleton();
+ 
+  private MySingleton() {   
+    // Private constructor prevents instantiation by untrusted callers
+  }
+ 
+  public static MySingleton getInstance() {   
+    return instance;
+  }
+}"
+JAVA,기타,싱글톤 객체의 다중 인스턴스화 방지,"CWE-543, 멀티스레드 컨텍스트에서 동기화 없이 싱글톤 패턴 사용","public static MySingleton getInstance() {
+  if (instance == null) {
+    synchronized (MySingleton.class) {
+      instance = new MySingleton();
+    }
+  }
+  return instance;
+}","class MySingleton {
+  private static MySingleton instance;
+ 
+  private MySingleton() {
+    // Private constructor prevents instantiation by untrusted callers
+  }
+ 
+  // Lazy initialization
+  public static synchronized MySingleton getInstance() {
+    if (instance == null) {
+      instance = new MySingleton();
+    }
+    return instance;
+  }
+}"
+JAVA,기타,싱글톤 객체의 다중 인스턴스화 방지,"CWE-543, 멀티스레드 컨텍스트에서 동기화 없이 싱글톤 패턴 사용","class MySingleton implements Cloneable {
+  private static MySingleton instance;
+ 
+  private MySingleton() {
+    // Private constructor prevents
+    // instantiation by untrusted callers
+  }
+ 
+  // Lazy initialization
+  public static synchronized MySingleton getInstance() {
+    if (instance == null) {
+      instance = new MySingleton();
+    }
+    return instance;
+  }
+}","class MySingleton implements Cloneable {
+  private static MySingleton instance;
+ 
+  private MySingleton() {
+    // Private constructor prevents instantiation by untrusted callers
+  }
+ 
+  // Lazy initialization
+  public static synchronized MySingleton getInstance() {
+    if (instance == null) {
+      instance = new MySingleton();
+    }
+    return instance;
+  }
+ 
+  public Object clone() throws CloneNotSupportedException {
+    throw new CloneNotSupportedException();
+  }
+}"
+JAVA,기타,싱글톤 객체의 다중 인스턴스화 방지,"CWE-543, 멀티스레드 컨텍스트에서 동기화 없이 싱글톤 패턴 사용","{
+  ClassLoader cl1 = new MyClassLoader();
+  Class class1 = cl1.loadClass(MySingleton.class.getName());
+  Method classMethod =
+      class1.getDeclaredMethod(""getInstance"", new Class[] { });
+  Object singleton = classMethod.invoke(null, new Object[] { });
+  System.out.println(singleton.hashCode());
+}
+ 
+ClassLoader cl1 = new MyClassLoader();
+Class class1 = cl1.loadClass(MySingleton.class.getName());
+Method classMethod =
+    class1.getDeclaredMethod(""getInstance"", new Class[] { });
+Object singleton = classMethod.invoke(null, new Object[] { } );
+System.out.println(singleton.hashCode());","{
+  ClassLoader cl1 = new MyClassLoader();
+  Class class1 = cl1.loadClass(MySingleton.class.getName());
+  Method classMethod =
+      class1.getDeclaredMethod(""getInstance"", new Class[] { });
+  Object singleton = classMethod.invoke(null, new Object[] { });
+  ObjectPreserver.preserveObject(singleton); // Preserve the object
+  System.out.println(singleton.hashCode());
+}
+ 
+ClassLoader cl1 = new MyClassLoader();
+Class class1 = cl1.loadClass(MySingleton.class.getName());
+Method classMethod =
+    class1.getDeclaredMethod(""getInstance"", new Class[] { });
+// Retrieve the preserved object
+Object singleton = ObjectPreserver.getObject(); 
+System.out.println(singleton.hashCode());"
+JAVA,기타,서블릿 내에서 세션 정보가 유출되지 않도록 하기,"CWE-543, 멀티스레드 컨텍스트에서 동기화 없이 싱글톤 패턴 사용","public class SampleServlet extends HttpServlet {
+ 
+  private String lastAddr = ""nobody@nowhere.com"";
+ 
+  public void doGet(HttpServletRequest request, HttpServletResponse response)
+    throws IOException, ServletException {
+    response.setContentType(""text/html"");
+    PrintWriter out = response.getWriter();
+    out.println(""<html>"");
+ 
+    String emailAddr = request.getParameter(""emailAddr"");
+ 
+    if (emailAddr != null) {
+      out.println(""Email Address:"");
+      out.println(sanitize(emailAddr));
+      out.println(""<br>Previous Address:"");
+      out.println(sanitize(lastAddr));
+    };
+ 
+    out.println(""<p>"");
+    out.print(""<form action=\"""");
+    out.print(""SampleServlet\"" "");
+    out.println(""method=POST>"");
+    out.println(""Parameter:"");
+    out.println(""<input type=text size=20 name=emailAddr>"");
+    out.println(""<br>"");
+    out.println(""<input type=submit>"");
+    out.println(""</form>"");
+ 
+    lastAddr = emailAddr;
+  }
+ 
+  public void doPost(HttpServletRequest request, HttpServletResponse response)
+    throws IOException, ServletException {
+    doGet(request, response);
+  }
+ 
+  // Filter the specified message string for characters
+  // that are sensitive in HTML.
+  public static String sanitize(String message) {
+    // ...
+  }
+}","public class SampleServlet extends HttpServlet {
+ 
+  public void doGet(HttpServletRequest request, HttpServletResponse response)
+    throws IOException, ServletException {
+    response.setContentType(""text/html"");
+    PrintWriter out = response.getWriter();
+    out.println(""<html>"");
+ 
+    String emailAddr = request.getParameter(""emailAddr"");
+    HttpSession session = request.getSession();
+    Object attr = session.getAttribute(""lastAddr"");
+    String lastAddr = (attr == null) ? ""null"" : attr.toString();
+ 
+    if (emailAddr != null) {
+      out.println(""Email Address::"");
+      out.println(sanitize(emailAddr));
+      out.println(""<br>Previous Email Address::"");
+      out.println(sanitize(lastAddr));
+    };
+ 
+    out.println(""<p>"");
+    out.print(""<form action=\"""");
+    out.print(""SampleServlet\"" "");
+    out.println(""method=POST>"");
+    out.println(""Parameter:"");
+    out.println(""<input type=text size=20 name=emailAddr>"");
+    out.println(""<br>"");
+    out.println(""<input type=submit>"");
+    out.println(""</form>"");
+ 
+    session.setAttribute(""lastAddr"", emailAddr);
+  }
+ 
+  public void doPost(HttpServletRequest request, HttpServletResponse response)
+    throws IOException, ServletException {
+    doGet(request, response);
+  }
+ 
+  // Filter the specified message string for characters
+  // that are sensitive in HTML.
+  public static String sanitize(String message) {
+    // ...
+  }
+}"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-134, 외부에서 제어되는 Format String 사용","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+import sys
+
+# Simulating a global include of sensitive information:
+ENCRYPTION_KEY = ""FL4G1""
+
+# Simulating a include per language:
+MESSAGE = ""Contract '{0.instance_name}' created for ""
+
+
+class MicroService:
+    """"""Fancy MicroService""""""
+    def __init__(self, instance_name):
+        self.instance_name = instance_name
+
+
+def front_end(customer):
+    """"""Display service instance""""""
+    message_format = MESSAGE + customer
+    mc = MicroService(""big time microservice"")
+    print(message_format.format(mc))
+
+
+#####################
+# exploiting above code example
+#####################
+if __name__ == ""__main__"":
+    if len(sys.argv) > 1:  # running from command line
+        # you can print the global encryption key by using '{0.__init__.__globals__[ENCRYPTION_KEY]}' as
+        # argument.
+        front_end(sys.argv[1])
+    else:
+        # running in your IDE, simulating command line:
+        # Printing the ENCRYPTION_KEY via the global accessible object
+        front_end(""{0.__init__.__globals__[ENCRYPTION_KEY]}"")","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+import sys
+from string import Template
+
+# Simulating a global include of sensitive information:
+ENCRYPTION_KEY = ""FL4G1""
+
+# Simulating a include per language for international support:
+MESSAGE = Template(""Contract '$instance_name' created for '$customer'"")
+
+
+class MicroService:
+    """"""Fancy MicroService""""""
+    def __init__(self, instance_name):
+        self.instance_name = instance_name
+
+    def get_instance_name(self) -> str:
+        """"""return instance_name as string""""""
+        return self.instance_name
+
+
+def front_end(customer):
+    """"""Display service instance""""""
+    mc = MicroService(""big time microservice"")
+    print(MESSAGE.substitute(instance_name=mc.get_instance_name(),
+                             customer=customer))
+
+
+#####################
+# exploiting above code example
+#####################
+if __name__ == ""__main__"":
+    if len(sys.argv) > 1:  # running from command line
+        # you can print the global encryption key by using '{0.__init__.__globals__[ENCRYPTION_KEY]}' as
+        # argument.
+        front_end(sys.argv[1])
+    else:
+        # running in your IDE, simulating command line:
+        # Printing the ENCRYPTION_KEY via the global accessible object
+        front_end(""{0.__init__.__globals__[ENCRYPTION_KEY]}"")"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-197, Numeric Truncation Error",""""""" Non-compliant Code Example """"""
+counter = 0.0
+while counter <= 1.0:
+    if counter == 0.8:
+        print(""we reached 0.8"")  
+        break  # never going to reach this
+    counter += 0.1",""""""" Compliant Code Example """"""
+counter = 0
+while counter <= 10:
+    value = counter/10
+    if value == 0.8:
+        print(""we reached 0.8"")
+        break
+    counter += 1"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-197, Numeric Truncation Error",""""""" Non-compliant Code Example """"""
+counter = 1.0 + 1e-16
+target = 1.0 + 1e-15
+while counter <= target:  # never ends
+    print(f""counter={counter / 10**16 :.20f}"")
+    print(f"" target={target / 10**16:.20f}"")
+    counter += 1e-16",""""""" Compliant Code Example """"""
+counter = 1
+target = 10
+while counter <= target:
+    print(f""counter={counter / 10**16 :.20f}"")
+    print(f"" target={target / 10**16:.20f}"")
+    counter += 1"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-400, 통제되지 않은 자원 소비 (일명 ""자원 고갈"")",""""""" Non-compliant Code Example """"""
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+
+def take_time(x):
+    print(f""Started Task: {x}"")
+    # Simulate work
+    for i in range(10):
+        time.sleep(1)
+    print(f""Completed Task: {x}"")
+
+
+def run_thread(_executor, var):
+    future = _executor.submit(take_time, var)
+    return future
+
+
+def interrupt(future):
+    print(future.cancel())
+    print(f""Interrupted: {future}"")
+
+
+#####################
+# Exploiting above code example
+#####################
+
+
+with ThreadPoolExecutor() as executor:
+    task = run_thread(executor, ""A"")
+    interrupt(task)",""""""" Compliant Code Example """"""
+import time
+from concurrent.futures import ThreadPoolExecutor
+from threading import Event
+
+
+def take_time(x, _event):
+    print(f""Started Task: {x}"")
+    # Simulate work
+    for _ in range(10):
+        if _event.is_set():
+            print(f""Interrupted Task: {x}"")
+            # Save partial results
+            return
+        time.sleep(1)
+    print(f""Completed Task: {x}"")
+
+
+def run_thread(_executor, var):
+    e = Event()
+    future = _executor.submit(take_time, var, e)
+    return future, e
+
+
+def interrupt(future, e):
+    """"""Cancel the task, just in case it is not yet running, and set the Event flag""""""
+    future.cancel()
+    e.set()
+
+
+#####################
+# Exploiting above code example
+#####################
+
+
+with ThreadPoolExecutor() as executor:
+    task, event = run_thread(executor, ""A"")
+    interrupt(task, event)"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-409, 고압축 데이터의 부적절한 처리(데이터 증폭)","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+import zipfile
+
+with zipfile.ZipFile(""zip_attack_test.zip"", mode=""r"") as archive:
+    archive.extractall()","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+import zipfile
+from pathlib import Path
+
+MAXSIZE = 100 * 1024 * 1024  # limit is in bytes
+MAXAMT = 5  # max amount of files, includes directories in the archive
+
+
+class ZipExtractException(Exception):
+    """"""Custom Exception""""""
+
+
+def path_validation(input_path, base_path, permit_subdirs=True):
+    """"""Ensure to have only allowed path names""""""
+    test_path = (Path(base_path) / input_path).resolve()
+    if permit_subdirs:
+        if not Path(base_path).resolve() in test_path.resolve().parents:
+            raise ZipExtractException(f""Filename {test_path} not in {Path(base_path)} directory"")
+    else:
+        if test_path.parent != Path(base_path).resolve():
+            raise ZipExtractException(f""Filename {test_path} not in {Path(base_path)} directory"")
+
+
+def extract_files(file, base_path):
+    """"""Unpack zip file into base_path""""""
+    with zipfile.ZipFile(file, mode=""r"") as archive:
+        dirs = []
+        # Validation:
+        if len(archive.infolist()) > MAXAMT:
+            raise ZipExtractException(f""Metadata check: too many files, limit is {MAXAMT}"")
+        for zm in archive.infolist():
+            if zm.file_size > MAXSIZE:
+                raise ZipExtractException(f""Metadata check: {zm.filename} is too big, limit is {MAXSIZE}"")
+            path_validation(zm.filename, base_path)
+            with archive.open(zm.filename, mode='r') as mte:
+                read_data = mte.read(MAXSIZE + 1)
+                if len(read_data) > MAXSIZE:
+                    raise ZipExtractException(f""File {zm.filename} bigger than {MAXSIZE}"")
+
+        if not Path(base_path).resolve().exists():
+            Path(base_path).resolve().mkdir(exist_ok=True)
+
+        for zm in archive.infolist():
+            # Extraction - create directories
+            if zm.is_dir():
+                dirs.append(Path(base_path).resolve().joinpath(zm.filename))
+
+        for directory in dirs:
+            Path.mkdir(directory)
+
+        for zm in archive.infolist():
+            with archive.open(zm.filename, mode='r') as mte:
+                xpath = Path(base_path).joinpath(mte.name).resolve()
+                print(f""Writing file {xpath}"")
+                # Skip if directory
+                if xpath not in dirs:  # check if file is a directory
+                    with open(xpath, mode=""wb"") as filehandle:
+                        filehandle.write(read_data)
+
+
+extract_files(""zip_attack_test.zip"", ""ziptemp"")"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-409, 고압축 데이터의 부적절한 처리(데이터 증폭)","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+import zipfile
+
+MAXSIZE = 100 * 1024 * 1024 # limit is in bytes
+
+with zipfile.ZipFile(""zip_attack_test.zip"", mode=""r"") as archive:
+    for member in archive.infolist():
+        if member.file_size >= MAXSIZE:
+            print(f""Unable to extract {member.filename}, exceeds size {MAXSIZE}"")
+        else:
+            print(f""Extracting {member.filename}"")
+            archive.extract(member.filename)","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+import zipfile
+from pathlib import Path
+
+MAXSIZE = 100 * 1024 * 1024  # limit is in bytes
+MAXAMT = 5  # max amount of files, includes directories in the archive
+
+
+class ZipExtractException(Exception):
+    """"""Custom Exception""""""
+
+
+def path_validation(input_path, base_path, permit_subdirs=True):
+    """"""Ensure to have only allowed path names""""""
+    test_path = (Path(base_path) / input_path).resolve()
+    if permit_subdirs:
+        if not Path(base_path).resolve() in test_path.resolve().parents:
+            raise ZipExtractException(f""Filename {test_path} not in {Path(base_path)} directory"")
+    else:
+        if test_path.parent != Path(base_path).resolve():
+            raise ZipExtractException(f""Filename {test_path} not in {Path(base_path)} directory"")
+
+
+def extract_files(file, base_path):
+    """"""Unpack zip file into base_path""""""
+    with zipfile.ZipFile(file, mode=""r"") as archive:
+        dirs = []
+        # Validation:
+        if len(archive.infolist()) > MAXAMT:
+            raise ZipExtractException(f""Metadata check: too many files, limit is {MAXAMT}"")
+        for zm in archive.infolist():
+            if zm.file_size > MAXSIZE:
+                raise ZipExtractException(f""Metadata check: {zm.filename} is too big, limit is {MAXSIZE}"")
+            path_validation(zm.filename, base_path)
+            with archive.open(zm.filename, mode='r') as mte:
+                read_data = mte.read(MAXSIZE + 1)
+                if len(read_data) > MAXSIZE:
+                    raise ZipExtractException(f""File {zm.filename} bigger than {MAXSIZE}"")
+
+        if not Path(base_path).resolve().exists():
+            Path(base_path).resolve().mkdir(exist_ok=True)
+
+        for zm in archive.infolist():
+            # Extraction - create directories
+            if zm.is_dir():
+                dirs.append(Path(base_path).resolve().joinpath(zm.filename))
+
+        for directory in dirs:
+            Path.mkdir(directory)
+
+        for zm in archive.infolist():
+            with archive.open(zm.filename, mode='r') as mte:
+                xpath = Path(base_path).joinpath(mte.name).resolve()
+                print(f""Writing file {xpath}"")
+                # Skip if directory
+                if xpath not in dirs:  # check if file is a directory
+                    with open(xpath, mode=""wb"") as filehandle:
+                        filehandle.write(read_data)
+
+
+extract_files(""zip_attack_test.zip"", ""ziptemp"")"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-410, 자원 풀 부족",""""""" Non-compliant Code Example """"""
+import logging
+import threading
+import time
+
+logging.basicConfig(level=logging.INFO)
+
+
+def process_message(message: str, processed_messages: list):
+    """""" Method simulating mediation layer i/o heavy work""""""
+    logging.debug(""process_message: started message   %s working %is"", message, int(message) / 10)
+    for _ in range(int(message)):
+        time.sleep(0.01)
+    logging.debug(""process_message: completed message %s"", message)
+    processed_messages.append(f""processed {message}"")
+
+
+class MessageAPI(object):
+    """"""Class simulating the front end facing API""""""
+
+    def add_messages(self, messages: list) -> list:
+        """""" Receives a list of messages to work on """"""
+        logging.info(""add_messages: got %i messages to process"", len(messages))
+        processed_messages = []
+        threads = []
+        for message in messages:
+            threads.append(
+                threading.Thread(target=process_message, args=[message, processed_messages]))
+            threads[-1].start()
+        logging.debug(""add_messages: submitted %i messages"", len(messages))
+        for thread in threads:
+            thread.join()
+        logging.info(""add_messages: messages_done=%i"", len(processed_messages))
+        return processed_messages
+
+
+#####################
+# exploiting above code example
+#####################
+mapi = MessageAPI()
+attacker_messages = [str(msg) for msg in range(1000)]
+print(""ATTACKER: start sending messages"")
+result_list = mapi.add_messages(attacker_messages)
+print(
+    f""ATTACKER: done sending {len(attacker_messages)} messages, got {len(result_list)} messages ""
+    f""back"")
+print(f""ATTACKER: result_list = {result_list}"")",""""""" Compliant Code Example """"""
+import logging
+import time
+from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import wait
+
+logging.basicConfig(level=logging.INFO)
+
+
+def process_message(message: str):
+    """""" Method simulating mediation layer i/o heavy work""""""
+    logging.debug(""process_message: started message   %s working %is"", message, int(message) / 10)
+    for _ in range(int(message)):
+        time.sleep(0.01)
+    logging.debug(""process_message: completed message %s"", message)
+    return f""processed {message}""
+
+
+class MessageAPI(object):
+    """"""Class simulating the front end facing API""""""
+    # TODO: Prevent the attacker from creating multiple MessageAPI objects
+
+    def __init__(self):
+        # TODO: set or handle timeout as it is provided by the mediation layer
+        self.timeout = 1
+        self.executor = ThreadPoolExecutor()
+
+    def add_messages(self, messages: list) -> list:
+        """""" Receives a list of messages to work on """"""
+        # TODO: limit on max messages from the mediation layer.
+        # TODO: input sanitation.
+        futures = []
+        # with self.executor:
+        for message in messages:
+            futures.append(self.executor.submit(process_message, message))
+        logging.debug(""add_messages: submitted %i messages, waiting for %is to complete."", len(messages), self.timeout)
+        messages_done, messages_not_done = wait(futures, timeout=self.timeout)
+        for future in messages_not_done:
+            future.cancel()
+
+        logging.info(""add_messages: messages_done=%i messages_not_done=%i"", len(messages_done), len(messages_not_done))
+        process_messages = []
+        for future in messages_done:
+            process_messages.append(future.result())
+        return process_messages
+
+
+#####################
+# exploiting above code example
+#####################
+mapi = MessageAPI()
+result_list = []
+attacker_messages = [str(msg) for msg in range(100)]
+print(""ATTACKER: start sending messages"")
+result_list = mapi.add_messages(attacker_messages)
+print(f""ATTACKER: done sending {len(attacker_messages)} messages, got {len(result_list)} messages back"")
+print(f""ATTACKER: result_list = {result_list}"")"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-410, 자원 풀 부족",""""""" Non-compliant Code Example """"""
+import logging
+import time
+from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import wait
+
+logging.basicConfig(level=logging.INFO)
+
+
+def process_message(message: str):
+    """""" Method simulating mediation layer i/o heavy work""""""
+    logging.debug(""process_message: started message   %s working %is"", message, int(message) / 10)
+    for _ in range(int(message)):
+        time.sleep(0.01)
+    logging.debug(""process_message: completed message %s"", message)
+    return f""processed {message}""
+
+
+class MessageAPI(object):
+    """"""Class simulating the front end facing API""""""
+
+    def __init__(self):
+        self.executor = ThreadPoolExecutor()
+        self.timeout = 1
+
+    def add_messages(self, messages: list) -> list:
+        """""" Receives a list of messages to work on """"""
+        futures = []
+        for message in messages:
+            futures.append(self.executor.submit(process_message, message))
+
+        logging.debug(""add_messages: submitted %i messages, waiting for %is to complete."",
+                      len(messages), self.timeout)
+        messages_done, messages_not_done = wait(futures, timeout=self.timeout)
+
+        logging.info(""add_messages: messages_done=%i messages_not_done=%i"", len(messages_done),
+                     len(messages_not_done))
+
+        process_messages = []
+        for future in messages_done:
+            process_messages.append(future.result())
+        return process_messages
+
+
+#####################
+# exploiting above code example
+#####################
+mapi = MessageAPI()
+result_list = []
+attacker_messages = [str(msg) for msg in range(1000)]
+print(""ATTACKER: start sending messages"")
+result_list = mapi.add_messages(attacker_messages)
+print(
+    f""ATTACKER: done sending {len(attacker_messages)} messages, got {len(result_list)} messages ""
+    f""back"")
+print(f""ATTACKER: result_list = {result_list}"")",""""""" Compliant Code Example """"""
+import logging
+import time
+from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import wait
+
+logging.basicConfig(level=logging.INFO)
+
+
+def process_message(message: str):
+    """""" Method simulating mediation layer i/o heavy work""""""
+    logging.debug(""process_message: started message   %s working %is"", message, int(message) / 10)
+    for _ in range(int(message)):
+        time.sleep(0.01)
+    logging.debug(""process_message: completed message %s"", message)
+    return f""processed {message}""
+
+
+class MessageAPI(object):
+    """"""Class simulating the front end facing API""""""
+    # TODO: Prevent the attacker from creating multiple MessageAPI objects
+
+    def __init__(self):
+        # TODO: set or handle timeout as it is provided by the mediation layer
+        self.timeout = 1
+        self.executor = ThreadPoolExecutor()
+
+    def add_messages(self, messages: list) -> list:
+        """""" Receives a list of messages to work on """"""
+        # TODO: limit on max messages from the mediation layer.
+        # TODO: input sanitation.
+        futures = []
+        # with self.executor:
+        for message in messages:
+            futures.append(self.executor.submit(process_message, message))
+        logging.debug(""add_messages: submitted %i messages, waiting for %is to complete."",
+                      len(messages), self.timeout)
+        messages_done, messages_not_done = wait(futures, timeout=self.timeout)
+        logging.info(""add_messages: messages_done=%i messages_not_done=%i"", len(messages_done),
+                     len(messages_not_done))
+        if len(messages_not_done) > 0:
+            # TODO: be graceful, warn a trusted client
+            logging.warning(""add_messages: %i messages taking longer than %is, %i more to process"",
+                            len(messages), self.timeout, len(messages_not_done))
+            messages_done, messages_not_done = wait(futures, timeout=self.timeout)
+            logging.info(""add_messages: messages_done=%i messages_not_done=%i"", len(messages_done),
+                         len(messages_not_done))
+        for future in messages_not_done:
+            future.cancel()
+
+        logging.info(""add_messages: messages_done=%i messages_not_done=%i"", len(messages_done),
+                     len(messages_not_done))
+        process_messages = []
+        for future in messages_done:
+            process_messages.append(future.result())
+        return process_messages
+
+
+#####################
+# exploiting above code example
+#####################
+mapi = MessageAPI()
+result_list = []
+attacker_messages = [str(msg) for msg in range(100)]
+print(""ATTACKER: start sending messages"")
+result_list = mapi.add_messages(attacker_messages)
+print(
+    f""ATTACKER: done sending {len(attacker_messages)} messages, got {len(result_list)} messages ""
+    f""back"")
+print(f""ATTACKER: result_list = {result_list}"")"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-426, 신뢰할 수 없는 검색 경로","# Non-compliant Code Example
+python3 -m http.server -b 127.0.0.42 8080","# Compliant Code Example
+python3 -I --check-hash-based-pycs always -m http.server -b 127.0.0.42 8080"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-502, 신뢰할 수 없는 데이터의 역직렬화",""""""" Non-Compliant Code Example """"""
+import platform
+import pickle
+
+
+class Message(object):
+    """"""Sample Message Object""""""
+    sender_id = 42
+    text = ""Some text""
+
+    def printout(self):
+        """"""prints content to stdout to demonstrate active content""""""
+        print(f""Message:sender_id={self.sender_id} text={self.text}"")
+
+
+class Preserver(object):
+    """"""Demonstrating deserialisation""""""
+
+    def can(self, _message: Message) -> bytes:
+        """"""Serializes a Message object.
+            Parameters:
+                _message (Message): Message object
+            Returns:
+                _jar (bytes): pickled jar as string
+        """"""
+        return pickle.dumps(_message)
+
+    def uncan(self, _jar) -> Message:
+        """"""De-serializes a Message object.
+            Parameters:
+                _jar (String): Pickled jar
+            Returns:
+                (Message): Message object
+        """"""
+        return pickle.loads(_jar)
+
+
+# serialization of a normal package
+p1 = Preserver()
+message = Message()
+message.printout()
+jar = p1.can(message)
+
+# sending or storing would happen here
+p2 = Preserver()
+message = None
+message = p2.uncan(jar)
+message.printout()
+
+#####################
+# exploiting above code example
+#####################
+print(""-"" * 10)
+print(""Attacker trying to read the message"")
+message = pickle.loads(jar)
+message.printout()
+
+print(""-"" * 10)
+if platform.system() == ""Windows"":
+    PAYLOAD = b""""""cos
+system
+(S'calc.exe'
+tR.""""""
+else:
+    PAYLOAD = b""""""cos
+system
+(S'whoami;uptime;uname -a;ls -la /etc/shadow'
+tR.""""""
+print(""Attacker trying to inject PAYLOAD"")
+p3 = Preserver()
+message = None
+message = p3.uncan(PAYLOAD)",""""""" Compliant Code Example """"""
+import platform
+import json
+ 
+ 
+class Message(object):
+    """"""Sample Message Object""""""
+    sender_id = int()
+    text = str()
+ 
+    def __init__(self):
+        self.sender_id = 42
+        self.text = ""Some text""
+ 
+    def printout(self):
+        print(f""sender_id: {self.sender_id}\ntext: {self.text}"")
+ 
+ 
+class Preserver(object):
+    """"""Demonstrating deserialisation""""""
+ 
+    def can(self, _message: Message) -> str:
+        """"""Serializes a Message object.
+            Parameters:
+                _message (Message): Message object
+            Returns:
+                _jar (bytes): jar as string
+        """"""
+        return json.dumps(vars(_message))
+ 
+    def uncan(self, _jar) -> Message:
+        """"""Verifies and de-serializes a Message object.
+            Parameters:
+                _jar (String): Pickled jar
+            Returns:
+                (Message): Message object
+        """"""
+        j = json.loads(_jar)
+        _message = Message()
+        _message.sender_id = int(j[""sender_id""])
+        _message.text = str(j[""text""])
+        return _message
+ 
+ 
+# serialization of a normal package
+p1 = Preserver()
+message = Message()
+jar = p1.can(message)
+print(jar)
+print(type(json.loads(jar)))
+ 
+# sending or storing would happen here
+p2 = Preserver()
+message = None
+message = p2.uncan(jar)
+message.printout()
+print(message.sender_id)
+ 
+#####################
+# exploiting above code example
+#####################
+print(""-"" * 10)
+print(""Attacker trying to read the message"")
+print(jar)
+message.printout()
+ 
+print(""-"" * 10)
+if platform.system() == ""Windows"":
+    PAYLOAD = b""""""cos
+system
+(S'calc.exe'
+tR.""""""
+else:
+    PAYLOAD = b""""""cos
+system
+(S'whoami;uptime;uname -a;ls -la /etc/shadow'
+tR.""""""
+print(""Attacker trying to inject PAYLOAD"")
+p3 = Preserver()
+message = None
+message = p3.uncan(PAYLOAD)"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-532, 로그 파일을 통한 정보 노출",""""""" Non-compliant Code Example """"""
+ 
+import logging
+ 
+ 
+def login_user(username, password, security_question):
+    """"""Function to login user with username password, and security question""""""
+    logging.info(
+        ""User %s login attempt: password=%s, security answer=%s"",
+        username, password, security_question
+    )
+ 
+    # Continue to other login functionality
+ 
+ 
+def main():
+    """"""Main function showing login functionality""""""
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
+    username = input(""Enter your username: "")
+    password = input(""Enter your password: "")
+    security_question = input(""What is the name of your favorite pet?: "")
+    login_user(username, password, security_question)
+ 
+ 
+main()",""""""" Compliant Code Example """"""
+ 
+import logging
+ 
+ 
+def login_user(username, password, security_question):
+    """"""Function to login user with username password, and security question""""""
+    logging.info(""User %s login attempt"", username)
+ 
+    # Continue to other login functionality
+ 
+ 
+def main():
+    """"""Main function showing login functionality""""""
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
+    username = input(""Enter your username: "")
+    password = input(""Enter your password: "")
+    security_question = input(""What is the name of your favorite pet?: "")
+    login_user(username, password, security_question)
+ 
+ 
+main()"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-532, 로그 파일을 통한 정보 노출",""""""" Non-compliant Code Example """"""
+ 
+import logging
+ 
+ 
+def process_order(address):
+    """"""Function for processing some online order""""""
+    logging.basicConfig(format='%(asctime)s %(levelname)s:%(message)s',
+                        level=logging.DEBUG)
+    logger = logging.getLogger(__name__)
+    logger.info(""Initial logging level: %s"",
+                logging.getLevelName(logger.getEffectiveLevel()))
+    logger.debug(""Processing order for address: %s"", address)
+ 
+    # Continue to process the order.
+ 
+ 
+process_order(""10 Grafton Street"")",""""""" Compliant Code Example """"""
+ 
+import logging
+ 
+ 
+def process_order(address):
+    logging.basicConfig(
+        format=""%(asctime)s %(levelname)s:%(message)s"", level=logging.INFO
+    )
+    logger = logging.getLogger(__name__)
+ 
+    logger.info(""Initial logging level: %s"", logger.getEffectiveLevel())
+ 
+    logger.debug(""Processing order for address: %s"", address)
+ 
+    # Continue to process the order.
+ 
+ 
+process_order(""10 Grafton Street"")"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-665, 부적절한 초기화",""""""" Non-compliant Code Example """"""
+from time import sleep
+from enum import Enum
+from threading import local, current_thread
+from concurrent.futures import ThreadPoolExecutor, wait
+
+
+class User(Enum):
+    GUEST = 1
+    ADMIN = 2
+
+
+class Session(object):
+    def __init__(self):
+        self.user = local()
+        self.set_user_as_guest()
+
+    def set_user_as_guest(self):
+        self.user.value = User.GUEST
+
+    def set_user(self, user):
+        self.user.value = user
+
+    def work_thread(self):
+        """""" Perform a task for the user in its own thread """"""
+        thread = current_thread()
+        print(f""{thread.name}: Working concurrently as {self.user.value}"")
+        sleep(1)  # To allow for worker threads to be reused
+
+
+class SessionPool(object):
+    def __init__(self):
+        self.num_of_threads = 2
+        self.session = Session()
+        self.executor = ThreadPoolExecutor(initializer=self.initializer,
+                                           max_workers=self.num_of_threads
+                                           )
+
+    def initializer(self):
+        thread = current_thread()
+        print(f""+++ {thread.name} initializer +++"")
+        self.session.set_user_as_guest()
+
+    def work_as_admin(self):
+        self.session.set_user(User.ADMIN)
+        self.session.work_thread()
+
+    def work_as_guest(self):
+        """"""Uses the default user (GUEST) to perform a task""""""
+        self.session.work_thread()
+
+    def execute_task(self, task):
+        return self.executor.submit(task)
+
+
+#####################
+# exploiting above code example
+#####################
+sp = SessionPool()
+futures = [
+    sp.execute_task(sp.work_as_admin),  # Thread 1, works as ADMIN
+    sp.execute_task(sp.work_as_guest),  # Thread 2, should work as GUEST
+    sp.execute_task(sp.work_as_guest),  # Thread 3, should work as GUEST
+]
+
+# To prevent the main thread from stopping before worker threads finish
+wait(futures)
+for future in futures:
+    future.result()",""""""" Compliant Code Example """"""
+from time import sleep
+from enum import Enum
+from threading import local, current_thread
+from concurrent.futures import ThreadPoolExecutor, wait
+
+
+class User(Enum):
+    GUEST = 1
+    ADMIN = 2
+
+
+class Session(object):
+    def __init__(self):
+        self.user = local()
+        self.set_user_as_guest()
+
+    def set_user_as_guest(self):
+        self.user.value = User.GUEST
+
+    def set_user(self, user):
+        self.user.value = user
+
+    def work_thread(self):
+        """""" Perform a task for the user in its own thread """"""
+        thread = current_thread()
+        print(f""{thread.name}: Working concurrently as {self.user.value}"")
+        sleep(1)  # To allow for worker threads to be reused
+
+
+class SessionPool(object):
+    def __init__(self):
+        self.num_of_threads = 2
+        self.session = Session()
+        self.executor = ThreadPoolExecutor(initializer=self.initializer,
+                                           max_workers=self.num_of_threads
+                                           )
+
+    def initializer(self):
+        thread = current_thread()
+        print(f""+++ {thread.name} initializer +++"")
+        self.session.set_user_as_guest()
+
+    def work_as_admin(self):
+        try:
+            self.session.set_user(User.ADMIN)
+            self.session.work_thread()
+        finally:
+            self.session.set_user_as_guest()
+
+    def work_as_guest(self):
+        """"""Uses the default user (GUEST) to perform a task""""""
+        self.session.work_thread()
+
+    def execute_task(self, task):
+        return self.executor.submit(task)
+
+
+#####################
+# exploiting above code example
+#####################
+sp = SessionPool()
+futures = [
+    sp.execute_task(sp.work_as_admin),  # Thread 1, works as ADMIN
+    sp.execute_task(sp.work_as_guest),  # Thread 2, should work as GUEST
+    sp.execute_task(sp.work_as_guest),  # Thread 3, should work as GUEST
+]
+
+# To prevent the main thread from stopping before worker threads finish
+wait(futures)
+for future in futures:
+    future.result()"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-665, 부적절한 초기화",""""""" Non-compliant Code Example """"""
+from time import sleep
+from enum import Enum
+from threading import local, current_thread
+from concurrent.futures import ThreadPoolExecutor, wait
+
+
+class User(Enum):
+    GUEST = 1
+    ADMIN = 2
+
+
+class Session(object):
+    def __init__(self):
+        self.user = local()
+        self.set_user_as_guest()
+
+    def set_user_as_guest(self):
+        self.user.value = User.GUEST
+
+    def set_user(self, user):
+        self.user.value = user
+
+    def work_thread(self):
+        """""" Perform a task for the user in its own thread """"""
+        thread = current_thread()
+        print(f""{thread.name}: Working concurrently as {self.user.value}"")
+        sleep(1)  # To allow for worker threads to be reused 
+
+
+class SessionPool(object):
+    def __init__(self):
+        self.num_of_threads = 3
+        self.session = Session()
+        self.executor = ThreadPoolExecutor(initializer=self.initializer,
+                                           max_workers=self.num_of_threads
+                                           )
+
+    def initializer(self):
+        thread = current_thread()
+        print(f""+++ {thread.name} initializer +++"")
+        self.session.set_user_as_guest()
+
+    def work_as_admin(self):
+        self.session.set_user(User.ADMIN)
+        self.session.work_thread()
+
+    def work_as_guest(self):
+        """"""Uses the default user (GUEST) to perform a task""""""
+        self.session.work_thread()
+
+    def execute_task(self, task):
+        return self.executor.submit(task)
+
+
+#####################
+# exploiting above code example
+#####################
+sp = SessionPool()
+futures = [
+    sp.execute_task(sp.work_as_admin),  # Thread 1, works as ADMIN
+    sp.execute_task(sp.work_as_guest),  # Thread 2, should work as GUEST
+    sp.execute_task(sp.work_as_guest),  # Thread 3, should work as GUEST
+]
+
+# To prevent the main thread from stopping before worker threads finish
+wait(futures)
+for future in futures:
+    future.result()","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+from time import sleep
+from enum import Enum
+from threading import local, current_thread
+from concurrent.futures import ThreadPoolExecutor, wait
+
+
+class User(Enum):
+    GUEST = 1
+    ADMIN = 2
+
+
+class Session(object):
+    def __init__(self):
+        self.user = local()
+        self.set_user_as_guest()
+
+    def set_user_as_guest(self):
+        self.user.value = User.GUEST
+
+    def set_user(self, user):
+        self.user.value = user
+
+    def work_thread(self):
+        """""" Perform a task for the user in its own thread """"""
+        thread = current_thread()
+        print(f""{thread.name}: Working concurrently as {self.user.value}"")
+        sleep(1)  # To allow for worker threads to be reused
+
+
+class SessionPool(object):
+    def __init__(self):
+        self.num_of_threads = 2
+        self.session = Session()
+        self.executor = ThreadPoolExecutor(initializer=self.initializer,
+                                           max_workers=self.num_of_threads
+                                           )
+
+    def initializer(self):
+        thread = current_thread()
+        print(f""+++ {thread.name} initializer +++"")
+        self.session.set_user_as_guest()
+
+    def work_as_admin(self):
+        self.session.set_user(User.ADMIN)
+        self.session.work_thread()
+
+    def work_as_guest(self):
+        """"""Uses the default user (GUEST) to perform a task""""""
+        self.session.set_user_as_guest()
+        self.session.work_thread()
+
+    def execute_task(self, task):
+        return self.executor.submit(task)
+
+
+#####################
+# exploiting above code example
+#####################
+sp = SessionPool()
+futures = [
+    sp.execute_task(sp.work_as_admin),  # Thread 1, works as ADMIN
+    sp.execute_task(sp.work_as_guest),  # Thread 2, should work as GUEST
+    sp.execute_task(sp.work_as_admin),  # Thread 1, works as ADMIN
+    sp.execute_task(sp.work_as_guest),  # Thread 3, should work as GUEST
+    sp.execute_task(sp.work_as_guest),  # Thread 2, should work as GUEST
+    sp.execute_task(sp.work_as_guest),  # Thread 3, should work as GUEST
+]
+# To prevent the main thread from stopping before worker threads finish
+wait(futures)
+for future in futures:
+    future.result()"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-681, 숫자 유형 간의 잘못된 변환",""""""" Non-compliant Code Example """"""
+s = str(4 / 2)
+print(f""s: {s}"")
+# s is ""2.0"", a string
+if s == ""2"":
+    print(""s equals 2"")
+# <no output>",""""""" Compliant Code Example """"""
+from decimal import Decimal
+ 
+t = Decimal(str(4 / 2))
+print(f""t: {t}"")
+# t still prints ""2.0"", but now it's a Decimal
+if Decimal(""2"").compare(t) == 0:
+    print(""t equals 2"")
+# prints ""t equals 2"""
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-833, Deadlock",""""""" Non-compliant Code Example """"""
+
+from concurrent.futures import ThreadPoolExecutor
+from typing import List
+
+
+class ReportTableGenerator(object):
+    def __init__(self):
+        self.executor = ThreadPoolExecutor()
+
+    def generate_string_table(self, inputs: List[str]) -> str:
+        futures = []
+        aggregated = ""|Data|Length|\n""
+        for i in inputs:
+            futures.append(self.executor.submit(self._create_table_row, i))
+        for future in futures:
+            aggregated += future.result()
+        return aggregated
+
+    def _create_table_row(self, row: str) -> str:
+        print(f""Creating a row out of: {row}"")
+        future = self.executor.submit(self._reformat_string, row)
+        return f""|{future.result()}|{len(row)}|\n""
+
+    def _reformat_string(self, row: str) -> str:
+        print(f""Reformatting {row}"")
+        row_reformated = row.capitalize()
+        return row_reformated
+
+
+#####################
+# exploiting above code example
+#####################
+report_table_generator = ReportTableGenerator()
+attacker_messages = [str(msg) for msg in range(1000)]
+print(""ATTACKER: start sending messages"")
+result = report_table_generator.generate_string_table(attacker_messages)
+print(
+    f""ATTACKER: done sending {len(attacker_messages)} messages, got {len(result)} messages ""
+    f""back"")
+print(f""ATTACKER: result = {result}"")",""""""" Compliant Code Example """"""
+
+from concurrent.futures import ThreadPoolExecutor
+from typing import List
+
+
+class ReportTableGenerator(object):
+    def __init__(self):
+        self.executor = ThreadPoolExecutor()
+
+    def generate_string_table(self, inputs: List[str]) -> str:
+        futures = []
+        aggregated = ""|Data|Length|\n""
+        for i in inputs:
+            futures.append(self.executor.submit(self._create_table_row, i))
+        for future in futures:
+            aggregated += future.result()
+        return aggregated
+
+    def _create_table_row(self, row: str) -> str:
+        print(f""Creating a row out of: {row}"")
+        return f""|{self._reformat_string(row)}|{len(row)}|\n""
+
+    def _reformat_string(self, row: str) -> str:
+        print(f""Reformatting {row}"")
+        row_reformated = row.capitalize()
+        return row_reformated
+
+
+#####################
+# exploiting above code example
+#####################
+report_table_generator = ReportTableGenerator()
+attacker_messages = [str(msg) for msg in range(1000)]
+print(""ATTACKER: start sending messages"")
+result = report_table_generator.generate_string_table(attacker_messages)
+print(
+    f""ATTACKER: done sending {len(attacker_messages)} messages, got {len(result)} messages ""
+    f""back"")
+print(f""ATTACKER: result = {result}"")"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-833, Deadlock",""""""" Non-compliant Code Example """"""
+
+from concurrent.futures import ThreadPoolExecutor, wait
+from threading import Lock
+from typing import Callable
+
+
+class BankingService(object):
+    def __init__(self, n: int):
+        self.executor = ThreadPoolExecutor()
+        self.number_of_times = n
+        self.count = 0
+        self.lock = Lock()
+
+    def for_each_client(self):
+        print(""For each client"")
+        self.invoke_method(self.for_each_account)
+
+    def for_each_account(self):
+        print(""For each account"")
+        self.invoke_method(self.for_each_card)
+
+    def for_each_card(self):
+        print(""For each card"")
+        self.invoke_method(self.check_card_validity)
+
+    def check_card_validity(self):
+        with self.lock:
+            self.count += 1
+            print(f""Number of checked cards: {self.count}"")
+
+    def invoke_method(self, method: Callable):
+        futures = []
+        for _ in range(self.number_of_times):
+            futures.append(self.executor.submit(method))
+        wait(futures)
+
+
+#####################
+# exploiting above code example
+#####################
+browser_manager = BankingService(5)
+browser_manager.for_each_client()",""""""" Compliant Code Example """"""
+
+from concurrent.futures import ThreadPoolExecutor, wait
+from threading import Lock
+from typing import Callable
+
+
+class BankingService(object):
+    def __init__(self, n: int):
+        self.executor = ThreadPoolExecutor()
+        self.number_of_times = n
+        self.count = 0
+        self.all_tasks = []
+        self.lock = Lock()
+
+    def for_each_client(self):
+        print(""Per client"")
+        self.invoke_method(self.for_each_account)
+
+    def for_each_account(self):
+        print(""Per account"")
+        self.invoke_method(self.for_each_card)
+
+    def for_each_card(self):
+        print(""Per card"")
+        self.invoke_method(self.check_card_validity)
+
+    def check_card_validity(self):
+        with self.lock:
+            self.count += 1
+            print(f""Number of checked cards: {self.count}"")
+
+    def invoke_method(self, method: Callable):
+        futures = []
+        for _ in range(self.number_of_times):
+            if self.can_fit_in_executor():
+                self.lock.acquire()
+                future = self.executor.submit(method)
+                self.all_tasks.append(future)
+                self.lock.release()
+                futures.append(future)
+            else:
+                # Execute the method in the thread that invokes it
+                method()
+        wait(futures)
+
+    def can_fit_in_executor(self):
+        running = 0
+        for future in self.all_tasks:
+            if future.running():
+                running += 1
+        print(f""Max workers: {self.executor._max_workers}, Used workers:  {running}"")
+        # Depending on the order of submitted subtasks, the script can sometimes deadlock
+        # if we don't leave a spare worker.
+        return self.executor._max_workers > running + 1
+
+
+#####################
+# exploiting above code example
+#####################
+browser_manager = BankingService(5)
+browser_manager.for_each_client()"
+Python,"CWE-664, 리소스의 수명 기간 동안 부적절한 제어",,"CWE-843, 호환되지 않는 유형을 사용한 리소스 액세스('유형 혼동')","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+
+
+def shopping_bag(price: int, qty: str) -> int:
+    return price * qty
+
+
+####################
+# attempting to exploit #above code example
+#####################
+print(shopping_bag(100, ""3""))","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+
+
+def shopping_bag(price: int, qty: str) -> int:
+    return int(price) * int(qty)
+
+
+####################
+# attempting to exploit #above code example
+#####################
+print(shopping_bag(100, ""3""))"
+Python,"CWE-682, 잘못된 계산",,"CWE-1335, 비트 단위 연산 대신 산술 연산으로 수학적 코드를 사용하여 가독성 및 호환성 향상",""""""" Non-compliant Code Example """"""
+
+print(8 << 2 + 10)",""""""" Compliant Code Example """"""
+
+print(8 * 4 + 10)"
+Python,"CWE-682, 잘못된 계산",,"CWE-1335, 비트 단위 연산 대신 산술 연산으로 수학적 코드를 사용하여 가독성 및 호환성 향상",""""""" Non-compliant Code Example """"""
+
+foo: int
+foo = -50
+foo >>= 2
+print(foo)",""""""" Compliant Code Example """"""
+
+foo: int = -50
+bar: float = foo / 4
+print(bar)"
+Python,"CWE-682, 잘못된 계산",,"CWE-1339, 실수의 부적절한 정밀도 또는 정확도","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+balance = 3.00
+item_cost = 0.33
+item_count = 5
+
+#####################
+# exploiting above code example
+#####################
+print(
+    f""{str(item_count)} items bought, ${item_cost} each. ""
+    f""Current account balance: ${str(balance - item_count * item_cost)}""
+)","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+balance = 300
+item_cost = 33
+item_count = 5
+
+#####################
+# exploiting above code example
+#####################
+print(
+    f""{str(item_count)} items bought, ${item_cost / 100} each. ""
+    f""Current account balance: ${str((balance - item_count * item_cost) / 100)}""
+)"
+Python,"CWE-682, 잘못된 계산",,"CWE-1339, 실수의 부적절한 정밀도 또는 정확도","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+balance = 3.00
+item_cost = 0.33
+item_count = 5
+
+#####################
+# exploiting above code example
+#####################
+print(
+    f""{str(item_count)} items bought, ${item_cost} each. ""
+    f""Current account balance: ${str(balance - item_count * item_cost)}""
+)","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+from decimal import Decimal
+
+balance = Decimal(""3.00"")
+item_cost = Decimal(""0.33"")
+item_count = 5
+
+#####################
+# exploiting above code example
+#####################
+print(
+    f""{str(item_count)} items bought, ${item_cost} each. ""
+    f""Current account balance: ${str(balance - item_count * item_cost)}""
+)"
+Python,"CWE-682, 잘못된 계산",,"CWE-191, 정수 언더플로(랩 또는 랩어라운드)",""""""" Non-compliant Code Example """"""
+
+import numpy
+
+a = numpy.int64(numpy.iinfo(numpy.int64).max)
+print(a + 1)  # RuntimeWarning and continues
+print()
+b = numpy.int64(numpy.iinfo(numpy.int64).max + 1)  # OverflowError and stops
+print(b)  # we will never reach this",""""""" Compliant Code Example """"""
+
+import warnings
+import numpy
+
+warnings.filterwarnings(""error"")
+a = numpy.int64(numpy.iinfo(numpy.int64).max)
+with warnings.catch_warnings():
+    try:
+        print(a + 1)
+    except Warning as _:
+        print(""Failed to increment "" + str(a) + "" due to overflow error"")
+    # RuntimeWarning and continues
+
+try:
+    b = numpy.int64(numpy.iinfo(numpy.int64).max + 1)  # OverflowError and stops
+except OverflowError as e:
+    print(""Failed to assign value to B due to overflow error"")"
+Python,"CWE-682, 잘못된 계산",,"CWE-191, 정수 언더플로(랩 또는 랩어라운드)",""""""" Non-compliant Code Example """"""
+ 
+import time
+ 
+ 
+def get_time_in_future(hours_in_future):
+    """"""Gets the time n hours in the future""""""
+    currtime = [tm for tm in time.localtime()]
+    currtime[3] = currtime[3] + hours_in_future
+    if currtime[3] + hours_in_future > 24:
+        currtime[3] = currtime[3] - 24
+    return time.asctime(tuple(currtime)).split("" "")[3]
+ 
+ 
+#####################
+# exploiting above code example
+#####################
+print(get_time_in_future(23**74))",""""""" Compliant Code Example """"""
+
+import time
+
+
+def get_time_in_future(hours_in_future):
+    """"""Gets the time n hours in the future""""""
+    try:
+        currtime = list(time.localtime())
+        currtime[3] = currtime[3] + hours_in_future
+        if currtime[3] + hours_in_future > 24:
+            currtime[3] = currtime[3] - 24
+        return time.asctime(tuple(currtime)).split("" "")[3]
+    except OverflowError as _:
+        return ""Number too large to set time in future "" + str(hours_in_future)
+
+
+#####################
+# attempting to exploit above code example
+#####################
+print(get_time_in_future(23**74))"
+Python,"CWE-682, 잘못된 계산",,"CWE-191, 정수 언더플로(랩 또는 랩어라운드)",""""""" Non-compliant Code Example """"""
+
+import math
+
+
+def calculate_exponential_value(number):
+    """"""Return 'E' raised to the power of different numbers:""""""
+    return math.exp(number)
+
+
+#####################
+# attempting to exploit above code example
+#####################
+print(calculate_exponential_value(1000))",""""""" Compliant Code Example """"""
+import math
+
+
+def calculate_exponential_value(number):
+    """"""Return 'E' raised to the power of different numbers:""""""
+    try:
+        return math.exp(number)
+    except OverflowError as _:
+        return ""Number "" + str(number) + "" caused an integer overflow""
+
+
+#####################
+# attempting to exploit above code example
+#####################
+print(calculate_exponential_value(710))"
+Python,"CWE-691, 불충분한 제어 흐름 관리",,"CWE-617, Reachable Assertion",""""""" Non-compliant Code Example """"""
+import math
+
+
+def my_exp(x):
+    assert x in range(
+        1, 710
+    ), f""Argument {x} is not valid""  # range(1, 709) produces 1-708
+    return math.exp(x)
+
+
+#####################
+# exploiting above code example
+#####################
+
+try:
+    print(my_exp(1))
+except (AssertionError, OverflowError, TypeError, ValueError) as e:
+    print(e)
+
+try:
+    print(my_exp(709))
+except (AssertionError, OverflowError, TypeError, ValueError) as e:
+    print(e)
+
+try:
+    print(my_exp(710))
+except (AssertionError, OverflowError, TypeError, ValueError) as e:
+    print(e)
+
+try:
+    print(my_exp(0))
+except (AssertionError, OverflowError, TypeError, ValueError) as e:
+    print(e)
+
+try:
+    print(my_exp(""b""))
+except (AssertionError, OverflowError, TypeError, ValueError) as e:
+    print(e)
+
+# output
+
+# $ python3.9 noncompliant01.py
+# 2.718281828459045
+# 8.218407461554972e+307
+# Argument 710 is not valid
+# Argument 0 is not valid
+# Argument b is not valid
+# $ python3.9 -O noncompliant01.py
+# 2.718281828459045
+# 8.218407461554972e+307
+# math range error
+# 1.0
+# must be real number, not str",""""""" Compliant Code Example """"""
+import math
+
+
+def my_exp(x):
+    if x not in range(1, 710):  # range(1, 709) produces 1-708
+        raise ValueError(f""Argument {x} is not valid"")
+    return math.exp(x)
+
+
+#####################
+# exploiting above code example
+#####################
+
+try:
+    print(my_exp(1))
+except (AssertionError, OverflowError, TypeError, ValueError) as e:
+    print(e)
+
+try:
+    print(my_exp(709))
+except (AssertionError, OverflowError, TypeError, ValueError) as e:
+    print(e)
+
+try:
+    print(my_exp(710))
+except (AssertionError, OverflowError, TypeError, ValueError) as e:
+    print(e)
+
+try:
+    print(my_exp(0))
+except (AssertionError, OverflowError, TypeError, ValueError) as e:
+    print(e)
+
+try:
+    print(my_exp(""b""))
+except (AssertionError, OverflowError, TypeError, ValueError) as e:
+    print(e)
+
+# output
+
+# $ python3.9 compliant01.py
+# 2.718281828459045
+# 8.218407461554972e+307
+# Argument 710 is not valid
+# Argument 0 is not valid
+# Argument b is not valid
+# $ python3.9 -O compliant01.py
+# 2.718281828459045
+# 8.218407461554972e+307
+# Argument 710 is not valid
+# Argument 0 is not valid
+# Argument b is not valid
+ "
+Python,"CWE-693, 보호 메커니즘 실패",,"CWE-184, 허용되지 않는 입력의 불완전한 목록","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+import re
+import unicodedata
+import sys
+
+sys.stdout.reconfigure(encoding=""UTF-8"")
+
+
+class TagFilter:
+    """"""Input validation for human language""""""
+
+    def filter_string(self, input_string: str) -> str:
+        """"""Normalize and validate untrusted string
+
+        Parameters:
+            input_string(string): String to validate
+        """"""
+        # normalize
+        _str = unicodedata.normalize(""NFKC"", input_string)
+
+        # validate, exclude dangerous tags
+        for tag in re.findall(""<[^>]*>"", _str):
+            if tag in [""<script>"", ""<img"", ""<a href""]:
+                raise ValueError(""Invalid input tag"")
+
+        # modify, keep only trusted human words
+        # _filtered_str = """".join(re.findall(r'([\//\w<>\s_-]+)', _str))
+        _filtered_str = """".join(re.findall(r""[/\w<>\s-]+"", _str))
+        if len(_str) - len(_filtered_str) != 0:
+            raise ValueError(""Invalid input string"")
+        return _filtered_str
+
+
+#####################
+# attempting to exploit above code example
+#####################
+names = [
+    ""YES 毛泽东先生"",
+    ""YES María Quiñones Marqués"",
+    ""YES Борис Николаевич Ельцин"",
+    ""YES Björk Guðmundsdóttir"",
+    ""YES 0123456789"",
+    ""YES <b>"",
+    ""YES <p>foo</p>"",
+    ""YES underscore_"",
+    ""YES dash-"",
+    ""NOK semicolon;"",
+    ""NOK noprint "" + ""\uFDD0"",
+    ""NOK noprint "" + ""\uFDEF"",
+    ""NOK <script"" + ""\uFDEF"" + "">"",
+    ""NOK <script生>"",
+    ""NOK and &"",
+]
+for name in names:
+    print(name, end="" "")
+    try:
+        TagFilter().filter_string(name)
+    except ValueError as e:
+        print("" Error: "" + str(e))
+    else:
+        print("" OK"")","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+import re
+import unicodedata
+import sys
+
+sys.stdout.reconfigure(encoding=""UTF-8"")
+
+
+class TagFilter:
+    """"""Input validation for human language""""""
+
+    def filter_string(self, input_string: str) -> str:
+        """"""Normalize and validate untrusted string
+
+        Parameters:
+            input_string(string): String to validate
+        """"""
+        # normalize
+        _str = unicodedata.normalize(""NFKC"", input_string)
+
+        # modify, keep only trusted human words
+        _filtered_str = """".join(re.findall(r""[/\w<>\s-]+"", _str))
+        if len(_str) - len(_filtered_str) != 0:
+            raise ValueError(""Invalid input string"")
+
+        # validate, only allow harmless tags
+        for tag in re.findall(""<[^>]*>"", _str):
+            if tag not in [""<b>"", ""<p>"", ""</p>""]:
+                raise ValueError(""Invalid input tag"")
+        return _str
+
+
+#####################
+# attempting to exploit above code example
+#####################
+names = [
+    ""YES 毛泽东先生"",
+    ""YES María Quiñones Marqués"",
+    ""YES Борис Николаевич Ельцин"",
+    ""YES Björk Guðmundsdóttir"",
+    ""YES 0123456789"",
+    ""YES <b>"",
+    ""YES <p>foo</p>"",
+    ""YES underscore_"",
+    ""YES dash-"",
+    ""NOK semicolon;"",
+    ""NOK noprint "" + ""\uFDD0"",
+    ""NOK noprint "" + ""\uFDEF"",
+    ""NOK <script"" + ""\uFDEF"" + "">"",
+    ""NOK <script生>"",
+    ""NOK and &"",
+]
+for name in names:
+    print(f""{name}"", end="" "")
+    try:
+        TagFilter().filter_string(name)
+    except ValueError as e:
+        print("" Error: "" + str(e))
+    else:
+        print("" OK"")"
+Python,"CWE-693, 보호 메커니즘 실패",,"CWE-330, 충분히 랜덤하지 않은 값의 사용","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+import random
+
+
+def generate_web_token():
+    """"""Poor random number generator""""""
+    return random.randrange(int(""1"" + ""0"" * 31), int(""9"" * 32), 1)
+
+
+#####################
+# attempting to exploit above code example
+#####################
+TOKEN = generate_web_token()
+print(f""Your insecure token is: {TOKEN}"")","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+import secrets
+
+
+def generate_web_token():
+    """"""Better cryptographic number generator""""""
+    return secrets.token_urlsafe()
+
+
+#####################
+# attempting to exploit above code example
+#####################
+TOKEN = generate_web_token()
+print(f""Your secure tokens is: {TOKEN}"")"
+Python,"CWE-693, 보호 메커니즘 실패",,"CWE-778, 불충분한 로깅","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+ 
+try:
+    result = 10 / 0
+except ZeroDivisionError as e:
+    print(""Error occurred:"", e)
+#Continues to execute","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+ 
+import logging
+ 
+try:
+    result = 10 / 0
+except ZeroDivisionError as e:
+    logging.critical(""Error occurred: Division by zero"")
+#Continues to execute"
+Python,"CWE-693, 보호 메커니즘 실패",,"CWE-798, 하드코딩된 자격 증명 사용","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+databaseIPAddress = ""192.168.0.1""
+print(databaseIPAddress)","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+import os
+print(os.environ[""databaseIPAddress""])"
+Python,"CWE-697, 잘못된 비교",,"CWE-595, 객체 내용 대신 객체 참조 비교",""""""" Non-compliant Code Example """"""
+
+class Integer:
+    def __init__(self, value):
+        self.value = value
+
+
+#####################
+# exploiting above code example
+#####################
+print(Integer(12) == Integer(12))
+# Prints False, as == operator compares id(self) == id(other) when __eq__ isn't implemented
+# As a result, the same will be true for comparing lists as they delegate comparison to the objects.
+print([Integer(12)] == [Integer(12)])
+# And this is equally this will always be False as well
+print(Integer(12) in [Integer(10), Integer(12)])",""""""" Compliant Code Example """"""
+ 
+ 
+class Integer:
+    def __init__(self, value):
+        self.value = value
+ 
+    def __eq__(self, other):
+        if isinstance(other, type(self)):
+            return self.value == other.value
+        if isinstance(other, int):
+            return self.value == other
+        return False
+ 
+ 
+#####################
+# exploiting above code example
+#####################
+# All these senarios will now show True
+print(Integer(12) == Integer(12))
+print([Integer(12)] == [Integer(12)])
+print(Integer(12) in [Integer(10), Integer(12)])
+ 
+# By adding the handling for int we also support
+print(Integer(12) == 12)"
+Python,"CWE-703, 비정상적이거나 예외적인 조건에 대한 부적절한 검사 또는 처리 확인 또는 처리",,"CWE-230, 누락된 값의 부적절한 처리","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+
+
+def balance_is_positive(value: str) -> bool:
+    """"""Returns True if there is still enough value for a transaction""""""
+    _value = float(value)
+    if _value == float(""NaN"") or _value is float(""NaN"") or _value is None:
+        raise ValueError(""Expected a float"")
+    if _value <= 0:
+        return False
+    else:
+        return True
+
+
+#####################
+# attempting to exploit above code example
+#####################
+print(balance_is_positive(""0.01""))
+print(balance_is_positive(""0.001""))
+print(balance_is_positive(""NaN""))","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+
+from decimal import ROUND_DOWN, Decimal
+
+
+def balance_is_positive(value: str) -> bool:
+    """"""Returns True if there is still enough value for a transaction""""""
+    # TODO: additional input sanitation for expected type
+    _value = Decimal(value)
+    # TODO: exception handling
+    return _value.quantize(Decimal("".01""), rounding=ROUND_DOWN) > Decimal(""0.00"")
+
+
+#####################
+# attempting to exploit above code example
+#####################
+print(balance_is_positive(""0.01""))
+print(balance_is_positive(""0.001""))
+print(balance_is_positive(""NaN""))"
+Python,"CWE-703, 비정상적이거나 예외적인 조건에 대한 부적절한 검사 또는 처리 확인 또는 처리",,"CWE-390, 조치 없이 오류 상태 감지","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+
+from time import sleep
+
+
+def exception_example():
+    """"""Non-compliant Code Example using bare except""""""
+    while True:
+        try:
+            sleep(1)
+            _ = 1 / 0
+        except:
+            print(""Don't care"")
+
+
+#####################
+# exploiting above code example
+#####################
+exception_example()","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+from time import sleep
+
+
+def exception_example():
+    """"""Compliant Code Example catching a specific exception""""""
+    while True:
+        sleep(1)
+        try:
+            _ = 1 / 0
+        except ZeroDivisionError:
+            print(""How is it now?"")
+
+
+#####################
+# exploiting above code example
+#####################
+exception_example()"
+Python,"CWE-703, 비정상적이거나 예외적인 조건에 대한 부적절한 검사 또는 처리 확인 또는 처리",,"CWE-390, 조치 없이 오류 상태 감지","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+
+import logging
+from pathlib import Path
+
+
+def exception_example(args: list):
+    """"""Non-compliant Code Example missing handling""""""
+    file_path = Path(Path.home(), args[0])
+    try:
+        file_handle = open(file_path, ""r"", encoding=""utf-8"")
+        _ = file_handle.readlines()
+    except Exception as exception:
+        logging.exception(exception)
+
+
+#####################
+# exploiting above code example
+#####################
+exception_example([""goblegoblegoble""])","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+
+from pathlib import Path
+
+
+def exception_example(args: list):
+    """"""Compliant code demonstrating a simplistic handling.
+    input validation or architectural are not demonstrated.
+    """"""
+    file_exists = False
+    path = Path(Path.home(), args[0])
+    while not file_exists:
+        try:
+            file_handle = open(path, ""r"", encoding=""utf-8"")
+            file_exists = True
+            print(file_handle.readlines())
+        except FileNotFoundError:
+            print(f""Unable to find file '{path.name}'"")
+            filename = input(""Please provide a valid filename: "")
+            path = Path(Path.home(), filename)
+
+
+#####################
+# exploiting above code example
+#####################
+exception_example([""goblegoblegoble""])"
+Python,"CWE-703, 비정상적이거나 예외적인 조건에 대한 부적절한 검사 또는 처리 확인 또는 처리",,"CWE-392, 오류 상태 보고 누락",""""""" Non-compliant Code Example """"""
+import math
+from concurrent.futures import ThreadPoolExecutor
+
+
+def get_sqrt(a):
+    return math.sqrt(a)
+
+
+def run_thread(var):
+    with ThreadPoolExecutor() as executor:
+        return executor.submit(get_sqrt, var)
+
+#####################
+# exploiting above code example
+#####################
+# get_sqrt will raise ValueError that will be suppressed by the ThreadPoolExecutor
+arg = -1
+result = run_thread(arg)  # The outcome of the task is unknown",""""""" Compliant Code Example """"""
+import math
+from concurrent.futures import ThreadPoolExecutor
+
+
+def get_sqrt(a):
+    return math.sqrt(a)
+
+
+def run_thread(var):
+    with ThreadPoolExecutor() as executor:
+        future = executor.submit(get_sqrt, var)
+        if future.exception() is not None:
+            # handle exception...
+            raise ValueError(f""Invalid argument: {var}"")
+        return future
+
+
+#####################
+# exploiting above code example
+#####################
+arg = -1
+result = run_thread(arg)  # Now code execution will be interrupted by ValueError"
+Python,"CWE-703, 비정상적이거나 예외적인 조건에 대한 부적절한 검사 또는 처리 확인 또는 처리",,"CWE-392, 오류 상태 보고 누락",""""""" Non-compliant Code Example """"""
+import math
+from concurrent.futures import ThreadPoolExecutor
+
+
+def get_sqrt(a):
+    return math.sqrt(a)
+
+
+def run_thread(var):
+    with ThreadPoolExecutor() as executor:
+        return executor.submit(get_sqrt, var)
+
+#####################
+# exploiting above code example
+#####################
+# get_sqrt will raise ValueError that will be suppressed by the ThreadPoolExecutor
+arg = -1
+result = run_thread(arg)  # The outcome of the task is unknown",""""""" Compliant Code Example """"""
+import math
+from concurrent.futures import ThreadPoolExecutor
+
+
+def get_sqrt(a):
+    return math.sqrt(a)
+
+
+def run_thread(var):
+    with ThreadPoolExecutor() as executor:
+        future = executor.submit(get_sqrt, var)
+        try:
+            res = future.result()
+            return res
+        except ValueError as e:
+            # handle exception...
+            raise ValueError(f""Invalid argument: {var}"") from None
+
+
+#####################
+# exploiting above code example
+#####################
+arg = -1
+result = run_thread(arg)  # Now code execution will be interrupted by ValueError"
+Python,"CWE-703, 비정상적이거나 예외적인 조건에 대한 부적절한 검사 또는 처리 확인 또는 처리",,"CWE-392, 오류 상태 보고 누락",""""""" Non-compliant Code Example """"""
+
+import math
+from concurrent.futures import ThreadPoolExecutor
+
+
+def get_sqrt(a):
+    return math.sqrt(a)
+
+
+def map_threads(x):
+    with ThreadPoolExecutor() as executor:
+        return executor.map(get_sqrt, x)
+
+
+#####################
+# exploiting above code example
+#####################
+
+# get_sqrt will raise ValueError that will be suppressed by the ThreadPoolExecutor
+args = [2, -1, 4]
+results = map_threads(args)
+for result in results:
+    print(result)  # Unhandled ValueError will be raised before all results are read",""""""" Compliant Code Example """"""
+
+import math
+from concurrent.futures import ThreadPoolExecutor
+
+
+def get_sqrt(a):
+    return math.sqrt(a)
+
+
+def map_threads(x):
+    with ThreadPoolExecutor() as executor:
+        result_gen = executor.map(get_sqrt, x)
+        ret = list()
+        invalid_arg = 0
+        try:
+            for res in result_gen:
+                ret.append(res)
+                invalid_arg += 1
+            return res
+        except ValueError as e:
+            # handle exception...
+            raise ValueError(
+                f""Invalid argument: {x[invalid_arg]} at list index {invalid_arg}""
+            ) from None
+
+
+#####################
+# exploiting above code example
+#####################
+args = [2, -1, 4]
+results = map_threads(args)
+for result in results:
+    print(
+        result
+    )  # The exception is handled, but the rest of the results are still unavailable"
+Python,"CWE-703, 비정상적이거나 예외적인 조건에 대한 부적절한 검사 또는 처리 확인 또는 처리",,"CWE-392, 오류 상태 보고 누락",""""""" Non-compliant Code Example """"""
+
+import math
+from concurrent.futures import ThreadPoolExecutor
+
+
+def get_sqrt(a):
+    return math.sqrt(a)
+
+
+def map_threads(x):
+    with ThreadPoolExecutor() as executor:
+        return executor.map(get_sqrt, x)
+
+
+#####################
+# exploiting above code example
+#####################
+
+# get_sqrt will raise ValueError that will be suppressed by the ThreadPoolExecutor
+args = [2, -1, 4]
+results = map_threads(args)
+for result in results:
+    print(result)  # Unhandled ValueError will be raised before all results are read",""""""" Compliant Code Example """"""
+
+import math
+from concurrent.futures import ThreadPoolExecutor
+
+
+def get_sqrt(a):
+    try:
+        return math.sqrt(a)
+    except ValueError as e:
+        print(f""Invalid argument: {a}"")
+        return None
+
+
+def map_threads(x):
+    with ThreadPoolExecutor() as executor:
+        return executor.map(get_sqrt, x)
+
+
+#####################
+# exploiting above code example
+#####################
+args = [2, -1, 4]
+results = map_threads(args)
+for result in results:
+    print(result)  # Now no exception is raised and we can read all of the results"
+Python,"CWE-703, 비정상적이거나 예외적인 조건에 대한 부적절한 검사 또는 처리 확인 또는 처리",,"CWE-754, 비정상적이거나 예외적인 조건에 대한 부적절한 검사","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+import sys
+
+
+class Package:
+    def __init__(self):
+        self.package_weight = float(1.0)
+
+    def put_in_the_package(self, object_weight):
+        value = float(object_weight)
+        print(f""Adding an object that weighs {value} units"")
+        self.package_weight += value
+
+    def get_package_weight(self):
+        return self.package_weight
+
+
+#####################
+# exploiting above code example
+#####################
+package = Package()
+print(f""\nOriginal package's weight is {package.get_package_weight():.2f} units\n"")
+for item in [sys.float_info.max, ""infinity"", ""-infinity"", ""nan""]:
+    try:
+        package.put_in_the_package(item)
+        print(f""Current package weight = {package.get_package_weight():.2f}\n"")
+    except Exception as e:
+        print(e)","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+import sys
+from math import isinf, isnan
+
+
+class Package:
+    def __init__(self):
+        self.package_weight = float(1.0)
+
+    def put_in_the_package(self, user_input):
+        try:
+            value = float(user_input)
+        except ValueError:
+            raise ValueError(f""{user_input} - Input is not a number!"")
+
+        print(f""value is {value}"")
+
+        if isnan(value) or isinf(value):
+            raise ValueError(f""{user_input} - Input is not a real number!"")
+
+        if value < 0:
+            raise ValueError(
+                f""{user_input} - Packed object weight  cannot be negative!""
+            )
+
+        if value >= sys.float_info.max - self.package_weight:
+            raise ValueError(f""{user_input} - Input exceeds acceptable range!"")
+        self.package_weight += value
+
+    def get_package_weight(self):
+        return self.package_weight
+
+
+#####################
+# exploiting above code example
+#####################
+package = Package()
+print(f""\nOriginal package's weight is {package.get_package_weight():.2f} units\n"")
+for item in [sys.float_info.max, ""infinity"", ""-infinity"", ""nan""]:
+    try:
+        package.put_in_the_package(item)
+        print(f""Current package weight = {package.get_package_weight():.2f}\n"")
+    except Exception as e:
+        print(e)"
+Python,"CWE-703, 비정상적이거나 예외적인 조건에 대한 부적절한 검사 또는 처리 확인 또는 처리",,"CWE-755, 예외 조건의 부적절한 처리",""""""" Non-compliant Code Example """"""
+ 
+import os
+import uuid
+ 
+ 
+def read_file(file):
+    """"""Function for opening a file and reading it's content.""""""
+    fd = os.open(file, os.O_RDONLY)
+    content = os.read(fd)
+    return content.decode()
+ 
+ 
+#####################
+# exploiting above code example
+#####################
+# Attempting to read a random non-existent file
+read_file(f""{uuid.uuid4()}.txt"")",""""""" Compliant Code Example """"""
+  
+import os
+import uuid
+  
+  
+def read_file(file):
+    """"""Function for opening a file and reading its content.""""""
+    try:
+        fd = os.open(file, os.O_RDONLY)
+        try:
+            content = os.read(fd, 1024)
+        finally:
+            os.close(fd)
+        return content.decode()
+    except OSError as e:
+        if not os.path.exists(file):
+            print(f""File not found: {file}"")
+        elif os.path.isdir(file):
+            print(f""Is a directory: {file}"")
+        else:
+            print(f""An error occurred: {e}"")
+  
+  
+#####################
+# exploiting above code example
+#####################
+# Attempting to read a random non-existent file
+read_file(f""{uuid.uuid4()}.txt"")"
+Python,"CWE-703, 비정상적이거나 예외적인 조건에 대한 부적절한 검사 또는 처리 확인 또는 처리",,"CWE-755, 예외 조건의 부적절한 처리",""""""" Non-compliant Code Example """"""
+ 
+import uuid
+from pathlib import Path
+ 
+ 
+def read_file(file):
+    """"""Function for opening a file and reading its content.""""""
+    path = Path(file)
+    content = path.read_text(encoding=""utf-8"")
+    return content
+ 
+ 
+#####################
+# exploiting above code example
+#####################
+# Attempting to read a random non-existent file
+read_file(f""{uuid.uuid4()}.txt"")",""""""" Non-compliant Code Example """"""
+ 
+import uuid
+from pathlib import Path
+ 
+ 
+def read_file(file):
+    """"""Function for opening a file and reading its content.""""""
+    path = Path(file)
+    try:
+        content = path.read_text(encoding=""utf-8"")
+        return content
+    except OSError as e:
+        if path.is_dir():
+            print(f""Is a directory: {file}"")
+        elif not path.exists():
+            print(f""File not found: {file}"")
+        else:
+            print(f""An error occurred: {e}"")
+        return None
+ 
+ 
+#####################
+# exploiting above code example
+#####################
+# Attempting to read a random non-existent file
+read_file(f""{uuid.uuid4()}.txt"")"
+Python,"CWE-703, 비정상적이거나 예외적인 조건에 대한 부적절한 검사 또는 처리 확인 또는 처리",,"CWE-755, 예외 조건의 부적절한 처리",""""""" Non-compliant Code Example """"""
+ 
+import pathlib
+import uuid
+ 
+ 
+def delete_temporary_file(file):
+    """"""Function for deleting a temporary file from a certain location""""""
+    resource_path = pathlib.Path(file)
+    resource_path.unlink(missing_ok=True)
+ 
+ 
+#####################
+# exploiting above code example
+#####################
+# Attempting to remove a random non-existent file
+delete_temporary_file(f""{uuid.uuid4()}.txt"")",""""""" Non-compliant Code Example """"""
+ 
+import uuid
+from pathlib import Path
+ 
+ 
+def read_file(file):
+    """"""Function for opening a file and reading its content.""""""
+    path = Path(file)
+    try:
+        content = path.read_text(encoding=""utf-8"")
+        return content
+    except OSError as e:
+        if path.is_dir():
+            print(f""Is a directory: {file}"")
+        elif not path.exists():
+            print(f""File not found: {file}"")
+        else:
+            print(f""An error occurred: {e}"")
+        return None
+ 
+ 
+#####################
+# exploiting above code example
+#####################
+# Attempting to read a random non-existent file
+read_file(f""{uuid.uuid4()}.txt"")"
+Python,"CWE-707, 부적절한 중립화 처���",,"CWE-117, 로그에 대한 부적절한 출력 중립화","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+import logging
+
+
+def log_authentication_failed(user):
+    """"""Simplified audit logging missing RFC 5424 details""""""
+    logging.warning(""User login failed for: '%s'"", user)
+
+
+#####################
+# attempting to exploit above code example
+#####################
+log_authentication_failed(""""""foo
+WARNING:root:User login failed for: administrator"""""")","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+import logging
+import re
+
+
+def allowed_chars(user):
+    """"""Verify only allowed characters are used""""""
+    if bool(re.compile(r""\w+"").fullmatch(user)):
+        return True
+    return False
+
+
+def log_authentication_failed(user):
+    """"""Simplified audit logging missing RFC 5424 details""""""
+    if not allowed_chars(user):
+        logging.critical(""Login attempt with non-allowed characters in user name: '%s'"", user)
+    logging.warning(""User login failed for: '%s'"", user)
+
+
+#####################
+# attempting to exploit above code example
+#####################
+log_authentication_failed(""""""foo
+WARNING:root:User login failed for: administrator"""""")"
+Python,"CWE-707, 부적절한 중립화 처리",,"CWE-175, 혼합 인코딩의 부적절한 처리",""""""" Non-compliant Code Example """"""
+import datetime
+import locale
+
+dt = datetime.datetime(2022, 3, 9, 12, 55, 35, 000000)
+
+
+def get_date(date):
+    # Return year month day tuple e.g. 2022, March, 09
+    return date.strftime(""%Y""), date.strftime(""%B""), date.strftime(""%d"")
+
+#####################
+# Trying to exploit above code example
+#####################
+
+
+CURRENT_LOCALE = 'en_IE.utf8'
+OTHER_LOCALE = 'uk_UA.utf8'
+
+locale.setlocale(locale.LC_ALL, CURRENT_LOCALE)
+# Month is 'March'
+curryear, currmonth, currdate = get_date(dt)
+
+locale.setlocale(locale.LC_ALL, OTHER_LOCALE)
+# Month is 'березень', i.e. berezen’
+otheryear, othermonth, otherdate = get_date(dt)
+
+if currmonth == othermonth:
+    print(""Locale-dependent months are equal"")
+else:
+    print(""Locale-dependent months are not equal"")",""""""" Compliant Code Example """"""
+import datetime
+import locale
+
+dt = datetime.datetime(2022, 3, 9, 12, 55, 35, 000000)
+
+CURRENT_LOCALE = 'en_IE.utf8'
+OTHER_LOCALE = 'uk_UA.utf8'
+
+#####################
+# Trying to exploit above code example
+#####################
+
+locale.setlocale(locale.LC_ALL, CURRENT_LOCALE)
+# Month is 'March'
+currmonth = dt.month
+locale.setlocale(locale.LC_ALL, OTHER_LOCALE)
+# Month is 'березень', i.e. berezen’
+othermonth = dt.month
+
+if currmonth == othermonth:
+    print(""Locale-independent months are equal"")
+else:
+    print(""Locale-independent months are not equal"")"
+Python,"CWE-707, 부적절한 중립화 처리",,"CWE-175, 혼합 인코딩의 부적절한 처리",""""""" Non-compliant Code Example """"""
+import io
+
+LOREM = """"""Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.""""""
+
+output = io.BytesIO()
+wrapper = io.TextIOWrapper(output, encoding='utf-8', line_buffering=True)
+wrapper.write(LOREM)
+wrapper.seek(0, 0)
+# Below outputs UnicodeDecodeError: 'utf-16-le' codec can't decode byte 0x2e in position 1336: truncated data
+print(f""{len(output.getvalue().decode('utf-16le'))} characters in string"")",""""""" Compliant Code Example """"""
+import io
+
+LOREM = """"""Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.""""""
+
+output = io.BytesIO()
+wrapper = io.TextIOWrapper(output, encoding='utf-8', line_buffering=True)
+wrapper.write(LOREM)
+wrapper.seek(0, 0)
+# 1337 characters in string
+print(f""{len(output.getvalue().decode('utf-8'))} characters in string"")"
+Python,"CWE-707, 부적절한 중립화 처리",,"CWE-180, 잘못된 동작 순서: 검증 전에 유효성 검사","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+import re
+import unicodedata
+
+
+def api_with_ids(suspicious_string):
+    """"""Fancy intrusion detection system(IDS)""""""
+    if re.search(""./"", suspicious_string):
+        normalized_string = unicodedata.normalize(""NFKC"", suspicious_string)
+        print(f""detected an attack sequence {normalized_string}"")
+    else:
+        print(""Nothing suspicious"")
+
+
+#####################
+# attempting to exploit above code example
+#####################
+# The MALICIOUS_INPUT is using:
+# \u2024 or ""ONE DOT LEADER""
+# \uFF0F or 'FULLWIDTH SOLIDUS'
+api_with_ids(""\u2024\u2024\uFF0F"" * 10 + ""passwd"")","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+import re
+import unicodedata
+
+
+def api_with_ids(suspicious_string):
+    """"""Fancy intrusion detection system(IDS)""""""
+    normalized_string = unicodedata.normalize(""NFKC"", suspicious_string)
+    if re.search(""./"", normalized_string):
+        print(""detected an attack sequence with . or /"")
+    else:
+        print(""Nothing suspicious"")
+
+
+#####################
+# attempting to exploit above code example
+#####################
+# The MALICIOUS_INPUT is using:
+# \u2024 or ""ONE DOT LEADER""
+# \uFF0F or 'FULLWIDTH SOLIDUS'
+api_with_ids(""\u2024\u2024\uFF0F"" * 10 + ""passwd"")"
+Python,"CWE-707, 부적절한 중립화 처리",,"CWE-78, OS 명령에 사용되는 특수 요소의 부적절한 무력화(OS Command Injection)",""""""" Non-compliant Code Example """"""
+# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+from subprocess import Popen
+import os
+
+
+class FileOperations:
+    """"""Helper class for file system operations""""""
+
+    def list_dir(self, dirname: str):
+        """"""List the contents of a directory""""""
+        if ""nt"" in os.name:
+            Popen(""dir "" + dirname, shell=True).communicate()
+        if ""posix"" in os.name:
+            Popen(""ls "" + dirname, shell=True).communicate()
+
+
+#####################
+# Trying to exploit above code example
+#####################
+if ""nt"" in os.name:
+    FileOperations().list_dir(""%HOMEPATH% & net user"")
+if ""posix"" in os.name:
+    FileOperations().list_dir(""/etc/shadow; head -1 /etc/passwd"")",""""""" Compliant Code Example """"""
+
+# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+import os
+from pathlib import Path
+
+
+def list_dir(dirname: str):
+    """"""List the contents of a directory recursively
+
+    Parameters:
+        dirname (string): Directory name
+    """"""
+    path = Path(dirname)
+    allowed_directory = Path.home()
+    # TODO: input sanitation
+    # TODO: Add secure logging
+    if Path(
+        allowed_directory.joinpath(dirname)
+        .resolve()
+        .relative_to(allowed_directory.resolve())
+    ):
+        for item in path.glob(""*""):
+            print(item)
+
+
+#####################
+# Trying to exploit above code example
+#####################
+# just to keep it clean we create folder for this test
+os.makedirs(""temp"", exist_ok=True)
+
+# simulating upload area (payload):
+print(""Testing Corrupted Directory"")
+if ""posix"" in os.name:
+    with open(""temp/toast.sh"", ""w"", encoding=""utf-8"") as file_handle:
+        file_handle.write(""uptime\n"")
+    os.makedirs(""temp/. -exec bash toast.sh {} +"", exist_ok=True)
+
+# running the query:
+list_dir(""temp"")"
+Python,"CWE-707, 부적절한 중립화 처리",,"CWE-78, OS 명령에 사용되는 특수 요소의 부적절한 무력화(OS Command Injection)","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+import os
+import shlex
+from subprocess import run
+
+
+def list_dir(dirname: str):
+    """"""Lists only 2 levels of folders in a default directory""""""
+    os.chdir(dirname)
+    cmd = ""find . -maxdepth 1 -type d""
+    result = run(shlex.split(cmd), check=True, capture_output=True)
+
+    for subfolder in result.stdout.decode(""utf-8"").splitlines():
+        cmd = ""find "" + subfolder + "" -maxdepth 1 -type d""
+        subresult = run(shlex.split(cmd), check=True, capture_output=True)
+        for item in subresult.stdout.decode(""utf-8"").splitlines():
+            print(item)
+
+
+#####################
+# Trying to exploit above code example
+#####################
+# just to keep it clean we create folder for this test
+os.makedirs(""temp"", exist_ok=True)
+
+# simulating upload area (payload):
+print(""Testing Corrupted Directory"")
+if ""posix"" in os.name:
+    with open(""temp/toast.sh"", ""w"", encoding=""utf-8"") as file_handle:
+        file_handle.write(""uptime\n"")
+    os.makedirs(""temp/. -exec bash toast.sh {} +"", exist_ok=True)
+
+# running the query:
+list_dir(""temp"")",""""""" Compliant Code Example """"""
+
+# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+import os
+from pathlib import Path
+
+
+def list_dir(dirname: str):
+    """"""List the contents of a directory recursively
+
+    Parameters:
+        dirname (string): Directory name
+    """"""
+    path = Path(dirname)
+    allowed_directory = Path.home()
+    # TODO: input sanitation
+    # TODO: Add secure logging
+    if Path(
+        allowed_directory.joinpath(dirname)
+        .resolve()
+        .relative_to(allowed_directory.resolve())
+    ):
+        for item in path.glob(""*""):
+            print(item)
+
+
+#####################
+# Trying to exploit above code example
+#####################
+# just to keep it clean we create folder for this test
+os.makedirs(""temp"", exist_ok=True)
+
+# simulating upload area (payload):
+print(""Testing Corrupted Directory"")
+if ""posix"" in os.name:
+    with open(""temp/toast.sh"", ""w"", encoding=""utf-8"") as file_handle:
+        file_handle.write(""uptime\n"")
+    os.makedirs(""temp/. -exec bash toast.sh {} +"", exist_ok=True)
+
+# running the query:
+list_dir(""temp"")"
+Python,"CWE-707, 부적절한 중립화 처리",,"CWE-838, 출력 컨텍스트에 부적절한 인코딩","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+  
+def report_record_attack(stream: bytearray):
+    print(""important text:"", stream.decode(""utf-8""))
+  
+#####################
+# attempting to exploit above code example
+#####################
+payload = bytearray(""user: 毛泽东先生 attempted a directory traversal"".encode(""utf-8""))
+# Introducing an error in the encoded text, a byte
+payload[3] = 128
+report_record_attack(payload)","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+""""""Compliant Code Example""""""
+
+import base64
+
+
+def report_record_attack(stream: bytearray):
+    try:
+        decoded_text = stream.decode(""utf-8"")
+    except UnicodeDecodeError as e:
+        # Encode the stream using Base64 if there is an exception
+        encoded_payload = base64.b64encode(stream).decode(""utf-8"")
+        # Logging encoded payload for forensic analysis
+        print(""Base64 Encoded Payload for Forensic Analysis:"", encoded_payload)
+        print(""Error decoding payload:"", e)
+    else:
+        print(""Important text:"", decoded_text)
+
+
+#####################
+# attempting to exploit above code example
+#####################
+payload = bytearray(""user: 毛泽东先生 attempted a directory traversal"".encode(""utf-8""))
+# Introducing an error in the encoded text, a byte
+payload[3] = 128
+report_record_attack(payload)"
+Python,"CWE-707, 부적절한 중립화 처리",,"CWE-89, SQL 명령에 사용된 특수 요소의 부적절한 무력화(SQL Injection)","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+import sqlite3
+
+
+class Records:
+    """""" Non-compliant code.
+        Possible SQL injection vector through string-based query construction
+    """"""
+
+    def __init__(self, data_base):
+        self.connection = sqlite3.connect(data_base)
+        self.cursor = self.connection.cursor()
+        self.cursor.execute(""CREATE TABLE IF NOT EXISTS Students(student TEXT)"")
+        self.connection.commit()
+
+    def get_record(self, name):
+        '''
+        Fetches a student record from the table for given name
+            Parameters:
+                name (string): A string with the student name
+            Returns:
+                object (fetchall): sqlite3.cursor.fetchall() object
+        '''
+        get_values = ""SELECT * FROM Students WHERE student = '{name}'"".format(name=name)
+        self.cursor.execute(get_values)
+        return self.cursor.fetchall()
+
+    def add_record(self, name=""""):
+        '''
+        Adds a student name to the table
+            Parameters:
+                name (string): A string with the student name
+        '''
+
+        add_values = ""INSERT INTO Students(student) VALUES('{name}');""
+        add_values_query = add_values.format(name=name)
+        try:
+            self.cursor.executescript(add_values_query)
+        except sqlite3.OperationalError as operational_error:
+            print(operational_error)
+        self.connection.commit()
+
+
+#####################
+# exploiting above code example
+#####################
+print(""sqlite3.sqlite_version="" + sqlite3.sqlite_version)
+records = Records(""school.db"")
+
+records.add_record(""Alice"")
+records.add_record(""Robert'); DROP TABLE students;--"")
+records.add_record(""Malorny"")
+
+print(records.get_record(""Alice""))
+# normal as ""Robert"" has not been added as ""Robert"":
+print(records.get_record(""Robert'); DROP TABLE students;--""))
+print(records.get_record(""Malorny""))","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+import sqlite3
+
+
+class Records:
+    """""" Compliant code, providing protection against injection.
+        Missing input sanitation as such.
+    """"""
+
+    def __init__(self, data_base: str):
+        self.connection = sqlite3.connect(data_base)
+        self.cursor = self.connection.cursor()
+        self.cursor.execute(""CREATE TABLE IF NOT EXISTS Students(student TEXT)"")
+        self.connection.commit()
+
+    def get_record(self, name: str) -> list:
+        '''
+        Fetches a student record from the table for given name
+            Parameters:
+                name (string): A string with the student name
+            Returns:
+                object (fetchall): sqlite3.cursor.fetchall() object
+        '''
+        data_tuple = (name,)
+        get_values = ""SELECT * FROM Students WHERE student = ?""
+        self.cursor.execute(get_values, data_tuple)
+        return self.cursor.fetchall()
+
+    def add_record(self, name: str):
+        '''
+        Adds a student name to the table
+            Parameters:
+                name (string): A string with the student name
+        '''
+
+        data_tuple = (name,)
+        add_values = """"""INSERT INTO Students VALUES (?)""""""
+        try:
+            self.cursor.execute(add_values, data_tuple)
+        except sqlite3.OperationalError as operational_error:
+            print(operational_error)
+        self.connection.commit()
+
+
+#####################
+# exploiting above code example
+#####################
+print(""sqlite3.sqlite_version="" + sqlite3.sqlite_version)
+records = Records(""school.db"")
+
+records.add_record(""Alice"")
+records.add_record(""Robert'); DROP TABLE students;--"")
+records.add_record(""Malorny"")
+
+print(records.get_record(""Alice""))
+# normal as ""Robert"" has not been added as ""Robert"":
+print(records.get_record(""Robert'); DROP TABLE students;--""))
+print(records.get_record(""Malorny""))"
+Python,"CWE-710, 코딩 표준의 부적절한 준수",,"CWE-1095, 루프 내 루프 조건 값 업데이트",""""""" Non-compliant Code Example """"""
+userlist = ['Alice', 'Bob', 'Charlie']
+print(f'Unmodified list: {userlist}')
+
+for user in userlist:
+    if user == 'Bob':
+        userlist.remove(user)
+
+print(f'Modified list: {userlist}')",""""""" Compliant Code Example """"""
+userlist = ['Alice', 'Bob', 'Charlie']
+print(f'Unmodified list: {userlist}')
+ 
+# Create a copy
+for user in userlist.copy():
+    if user == 'Bob':
+        userlist.remove(user)
+ 
+print(f'Modified list: {userlist}')
+ 
+# Create a sample collection: list
+userlist2 = ['Alice', 'Bob', 'Charlie']
+print(f'Unmodified list: {userlist2}')
+ 
+# Create new list
+activeusers = []
+for user in userlist2:
+    if user != 'Bob':
+        activeusers.append(user)
+print(f'New list: {activeusers}')"
+Python,"CWE-710, 코딩 표준의 부적절한 준수",,"CWE-1095, 루프 내 루프 조건 값 업데이트",""""""" Non-compliant Code Example """"""
+userdict = {'Alice': 'active', 'Bob': 'inactive', 'Charlie': 'active'}
+print(f'Unmodified dict: {userdict}')
+
+for user, status in userdict.items():
+    if status == 'inactive':
+        del userdict[user]
+
+print(f'Modified dict: {userdict}')",""""""" Compliant Code Example """"""
+userdict = {'Alice': 'active', 'Bob': 'inactive', 'Charlie': 'active'}
+print(f'Unmodified dict: {userdict}')
+
+# Create a copy
+for user, status in userdict.copy().items():
+    if status == 'inactive':
+        del userdict[user]
+
+print(f'Modified dict: {userdict}')
+
+# Create new dict
+userdict2 = {'Alice': 'active', 'Bob': 'inactive', 'Charlie': 'active'}
+activeuserdict = {}
+for user, status in userdict2.items():
+    if status != 'inactive':
+        activeuserdict.update({user: status})
+
+print(f'New dict: {activeuserdict}')"
+Python,"CWE-710, 코딩 표준의 부적절한 준수",,"CWE-1095, 루프 내 루프 조건 값 업데이트",""""""" Non-compliant Code Example """"""
+userset = {'Alice', 'Bob', 'Charlie'}
+print(f'Unmodified set: {userset}')
+for user in userset:
+    if user == 'Bob':
+        userset.remove(user)",""""""" Compliant Code Example """"""
+userset = {'Alice', 'Bob', 'Charlie'}
+print(f'Unmodified set: {userset}')
+
+# Create a copy
+for user in userset.copy():
+    if user == 'Bob':
+        userset.remove(user)
+
+print(f'Modified set: {userset}')
+
+# Create a new set
+userset2 = {'Alice', 'Bob', 'Charlie'}
+activeuserset = set()
+for user in userset2:
+    if user != 'Bob':
+        activeuserset.add(user)
+
+print(f'Modified set: {activeuserset}')"
+Python,"CWE-710, 코딩 표준의 부적절한 준수",,"CWE-1109, 여러 목적에 동일한 변수 사용","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+numbers = [""one"", ""two"", ""three""]
+
+print(f""len({numbers}) == {len(numbers)}"")
+
+
+def len(x):
+    """""" implementing a dodgy version of a build in method """"""
+    return sum(1 for _ in x) + 1
+
+
+print(f""len({numbers}) == {len(numbers)}"")","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+numbers = [""one"", ""two"", ""three""]
+
+print(f""len({numbers}) == {len(numbers)}"")
+
+
+def custom_len(x):
+    """""" implementing a dodgy version of a build in method """"""
+    return sum(1 for _ in x) + 1
+
+
+print(f""len({numbers}) == {len(numbers)}"")"
+Python,"CWE-710, 코딩 표준의 부적절한 준수",,"CWE-1109, 여러 목적에 동일한 변수 사용","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Non-compliant Code Example """"""
+import os
+print(f""Logged in user is {os.getlogin()}"")
+
+
+class os:
+    """""" redefining standard class """"""
+
+    @staticmethod
+    def getlogin():
+        """""" redefining standard class method """"""
+        return ""Not implemented""
+
+
+print(f""Logged in user is {os.getlogin()}"")","# SPDX-FileCopyrightText: OpenSSF project contributors
+# SPDX-License-Identifier: MIT
+"""""" Compliant Code Example """"""
+import os
+
+print(f""Logged in user is {os.getlogin()}"")
+
+
+class custom_os:
+    """""" redefining standard class """"""
+
+    @staticmethod
+    def getlogin():
+        """""" redefining standard class method """"""
+        return ""Not implemented""
+
+
+print(f""Logged in user is {os.getlogin()}"")"