language
stringclasses 10
values | tag
stringclasses 34
values | vulnerability_type
stringlengths 4
68
⌀ | description
stringlengths 7
146
⌀ | vulnerable_code
stringlengths 14
1.96k
| secure_code
stringlengths 18
3.21k
|
|---|---|---|---|---|---|
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(®ex, “.*￦￦.￦￦..*”, 0);
// 경로 조작 가능성 있는 문자열 탐지
ret = regexec(®ex, filename, 0, NULL, 0);
If (!ret) {
// 경로 조작 문자열 발견, 오류 처리
}
// 필터링된 파일 이름으로 사용
fin = fopen(filename, “r”);
while (fgets(buf, BUF_LEN, fin)) {
// 파일 내용 출력
} |
JAVA | 입력데이터 검증 및 표현 | 크로스사이트 스크립트 | 사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한 보안약점 | <% String keyword = request.getParameter("keyword"); %>
//외부 입력값에 대하여 검증 없이 화면에 출력될 경우 공격스크립트가 포함된 URL을 생성 할 수 있어
안전하지 않다.(Reflected XSS)
검색어 : <%=keyword%>
//게시판 등의 입력form으로 외부값이 DB에 저장되고, 이를 검증 없이 화면에 출력될 경우
공격스크립트가 실행되어 안전하지 않다.(Stored XSS)
검색결과 : $ {m.content}
<script type="text/javascript">
//외부 입력값에 대하여 검증 없이 브라우저에서 실행되는 경우 서버를 거치지 않는 공격스크립트가
포함된 URL을 생성 할 수 있어 안전하지 않다. (DOM 기반 XSS)
document.write("keyword:" + <%=keyword%>);
</script> | <% String keyword = request.getParameter("keyword"); %>
// 방법1. 입력값에 대하여 스크립트 공격가능성이 있는 문자열을 치환한다.
keyword = keyword.replaceAll("&", "&");
keyword = keyword.replaceAll("<", "<");
keyword = keyword.replaceAll(">", ">");
keyword = keyword.replaceAll("￦"", """);
keyword = keyword.replaceAll("'", "'");
keyword = keyword.replaceAll("/"", "/");
keyword = keyword.replaceAll("(", "(");
keyword = keyword.replaceAll(")", ")");
검색어 : <%=keyword%>
//방법2. JSP에서 출력값에 JSTL c:out 을 사용하여 처리한다.
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
검색결과 : <c: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);
}
...
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.