输入验证与表示问题是由元字符、交替编码和数字表示引起的。安全问题源于信任输入。这些问题包括:“Buffer Overflows”、“Cross-Site Scripting”攻击、“SQL Injection”等其他问题。
nresp = packet_get_int();
if (nresp > 0) {
response = xmalloc(nresp*sizeof(char*));
for (i = 0; i < nresp; i++)
response[i] = packet_get_string(NULL);
}
nresp
拥有值 1073741824
,sizeof(char*)
拥有典型值 4
,那么 nresp*sizeof(char*)
的操作结果将溢出,xmalloc()
参数将变为 0
。大多数 malloc()
实施将允许分配 0 字节缓冲区,导致随后的循环迭代次数超出堆缓冲区 response
。
char* processNext(char* strm) {
char buf[512];
short len = *(short*) strm;
strm += sizeof(len);
if (len <= 512) {
memcpy(buf, strm, len);
process(buf);
return strm + len;
} else {
return -1;
}
}
512
,输入将不会被处理。问题是 len
为一个带符号的整数,因此针对最大结构长度的检查是用带符号的整数完成的,但是针对 memcpy()
调用,len
会转化为一个不带符号的整数。如果 len
为负,那么结构将看起来有一个适当的尺寸(将执行 if
分支),但是通过 memcpy()
复制的内存数量将相当大,攻击者将能够使用 strm
中的数据溢出堆栈。
77 accept-in PIC 9(10).
77 num PIC X(4) COMP-5. *> native 32-bit unsigned integer
77 mem-size PIC X(4) COMP-5.
...
ACCEPT accept-in
MOVE accept-in TO num
MULTIPLY 4 BY num GIVING mem-size
CALL "CBL_ALLOC_MEM" USING
mem-pointer
BY VALUE mem-size
BY VALUE 0
RETURNING status-code
END-CALL
num
拥有值 1073741824
,则操作 MULTIPLY 4 BY num
的结果会溢出,并且参数 mem-size
到 malloc()
将是 0
。大多数 malloc()
实现允许分配 0 字节的缓冲区,这会导致堆缓冲区 mem-pointer
在后续语句中溢出。uint256
类型存储,则意味着它以 0 到 2^256-1 范围内的 256 位无符号数字存储。如果算术运算的结果大于上限,则发生上溢,从起始值 (0) 开始加上余数。如果算术运算的结果低于下限,则发生下溢,从最大值 (2^256-1) 中减去余数。uint256
映射,该算术运算可能导致整数上溢/下溢并影响映射中的意外索引。
contract overflow {
mapping(uint256 => uint256) map;
function init(uint256 k, uint256 v) public {
map[k] -= v;
}
}
String arg = request.getParameter("arg");
...
Intent intent = new Intent();
...
intent.setClassName(arg);
ctx.startActivity(intent);
...
Intent
启动活动、启动服务或传递广播,可使攻击者能够任意启动内部应用程序组件、控制内部组件的行为,或通过临时授权间接访问内容提供者提供的受保护数据。Intent
的 Extra 捆绑包中嵌套的任意 Intent
。Intent
,通过调用 startActivity
、startService
或 sendBroadcast
来启动组件。Intent
,并使用该 Intent
启动活动。
...
Intent nextIntent = (Intent) getIntent().getParcelableExtra("next-intent");
startActivity(nextIntent);
...
username
和 password
序列化为位于 C:\user_info.json
的 JSON 文件:
...
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
using (JsonWriter writer = new JsonTextWriter(sw))
{
writer.Formatting = Formatting.Indented;
writer.WriteStartObject();
writer.WritePropertyName("role");
writer.WriteRawValue("\"default\"");
writer.WritePropertyName("username");
writer.WriteRawValue("\"" + username + "\"");
writer.WritePropertyName("password");
writer.WriteRawValue("\"" + password + "\"");
writer.WriteEndObject();
}
File.WriteAllText(@"C:\user_info.json", sb.ToString());
JsonWriter.WriteRawValue()
来执行,将不会对 username
和 password
中的不可信赖数据进行验证以转义与 JSON 相关的特殊字符。这样,用户就可以任意插入 JSON 密钥,可能会更改已序列化的 JSON 的结构。在本例中,在设置 username
的值的提示符下输入用户名时,如果非特权用户 mallory
(密码为 Evil123!
)将 ","role":"admin
附加到其用户名中,则最终保存到 C:\user_info.json
的 JSON 将为:
{
"role":"default",
"username":"mallory",
"role":"admin",
"password":"Evil123!"
}
Dictionary
对象,其中 JsonConvert.DeserializeObject()
如下所示:
String jsonString = File.ReadAllText(@"C:\user_info.json");
Dictionary<string, string> userInfo = JsonConvert.DeserializeObject<Dictionary<string, strin>>(jsonString);
Dictionary
对象中 username
、password
和 role
密钥的最终值将分别为 mallory
、Evil123!
和 admin
。在没有进一步验证反序列化 JSON 值是否有效的情况下,应用程序会错误地为用户分配 mallory
“管理员”特权。username
和 password
序列化为位于 ~/user_info.json
的 JSON 文件:
...
func someHandler(w http.ResponseWriter, r *http.Request){
r.parseForm()
username := r.FormValue("username")
password := r.FormValue("password")
...
jsonString := `{
"username":"` + username + `",
"role":"default"
"password":"` + password + `",
}`
...
f, err := os.Create("~/user_info.json")
defer f.Close()
jsonEncoder := json.NewEncoder(f)
jsonEncoder.Encode(jsonString)
}
username
和 password
中的不可信赖数据进行验证以转义与 JSON 相关的特殊字符。这样,用户就可以任意插入 JSON 密钥,这可能会更改已序列化的 JSON 结构。在本例中,如果非特权用户 mallory
(密码为 Evil123!
)在输入其用户名时附加了 ","role":"admin
,则最终保存到 ~/user_info.json
的 JSON 将为:
{
"username":"mallory",
"role":"default",
"password":"Evil123!",
"role":"admin"
}
mallory
“管理员”特权。username
和 password
序列化为位于 ~/user_info.json
的 JSON 文件:
...
JsonFactory jfactory = new JsonFactory();
JsonGenerator jGenerator = jfactory.createJsonGenerator(new File("~/user_info.json"), JsonEncoding.UTF8);
jGenerator.writeStartObject();
jGenerator.writeFieldName("username");
jGenerator.writeRawValue("\"" + username + "\"");
jGenerator.writeFieldName("password");
jGenerator.writeRawValue("\"" + password + "\"");
jGenerator.writeFieldName("role");
jGenerator.writeRawValue("\"default\"");
jGenerator.writeEndObject();
jGenerator.close();
JsonGenerator.writeRawValue()
来执行,将不会对 username
和 password
中的不可信赖数据进行验证以转义与 JSON 相关的特殊字符。这样,用户就可以任意插入 JSON 密钥,可能会更改已序列化的 JSON 的结构。在本例中,在设置 username
的值的提示符下输入用户名时,如果非特权用户 mallory
(密码为 Evil123!
)将 ","role":"admin
附加到其用户名中,则最终保存到 ~/user_info.json
的 JSON 将为:
{
"username":"mallory",
"role":"admin",
"password":"Evil123!",
"role":"default"
}
HashMap
对象,其中 Jackson 的 JsonParser
如下所示:
JsonParser jParser = jfactory.createJsonParser(new File("~/user_info.json"));
while (jParser.nextToken() != JsonToken.END_OBJECT) {
String fieldname = jParser.getCurrentName();
if ("username".equals(fieldname)) {
jParser.nextToken();
userInfo.put(fieldname, jParser.getText());
}
if ("password".equals(fieldname)) {
jParser.nextToken();
userInfo.put(fieldname, jParser.getText());
}
if ("role".equals(fieldname)) {
jParser.nextToken();
userInfo.put(fieldname, jParser.getText());
}
if (userInfo.size() == 3)
break;
}
jParser.close();
HashMap
对象中 username
、password
和 role
密钥的最终值将分别为 mallory
、Evil123!
和 admin
。在没有进一步验证反序列化 JSON 值是否有效的情况下,应用程序会错误地为用户分配 mallory
“管理员”特权。
var str = document.URL;
var url_check = str.indexOf('name=');
var name = null;
if (url_check > -1) {
name = decodeURIComponent(str.substring((url_check+5), str.length));
}
$(document).ready(function(){
if (name !== null){
var obj = jQuery.parseJSON('{"role": "user", "name" : "' + name + '"}');
...
}
...
});
name
中的不可信数据进行验证,以避免与 JSON 相关的特殊字符。这样,用户就可以任意插入 JSON 密钥,可能会更改已序列化的 JSON 的结构。在此示例中,如果非特权用户 mallory
将 ","role":"admin
附加到 URL 中的名称参数,JSON 将变成:
{
"role":"user",
"username":"mallory",
"role":"admin"
}
jQuery.parseJSON()
解析,并设置为普通对象,这意味着 obj.role
将立即返回 "admin" 而不是 "user"_usernameField
和 _passwordField
序列化为 JSON。
...
NSString * const jsonString = [NSString stringWithFormat: @"{\"username\":\"%@\",\"password\":\"%@\",\"role\":\"default\"}" _usernameField.text, _passwordField.text];
NSString.stringWithFormat:
来执行,将不会对 _usernameField
和 _passwordField
中的不可信赖数据进行验证以转义与 JSON 相关的特殊字符。这样,用户就可以任意插入 JSON 密钥,可能会更改已序列化的 JSON 的结构。在本例中,如果非特权用户 mallory
(密码为 Evil123!
)在将 ","role":"admin
输入 _usernameField
字段时将其附加到其用户名中,则最终 JSON 将为:
{
"username":"mallory",
"role":"admin",
"password":"Evil123!",
"role":"default"
}
NSDictionary
对象,其中 NSJSONSerialization.JSONObjectWithData:
如下所示:
NSError *error;
NSDictionary *jsonData = [NSJSONSerialization JSONObjectWithData:[jsonString dataUsingEncoding:NSUTF8StringEncoding] options:NSJSONReadingAllowFragments error:&error];
NSDictionary
对象中 username
、password
和 role
的最终值将分别为 mallory
、Evil123!
和 admin
。在没有进一步验证反序列化 JSON 值是否有效的情况下,应用程序会错误地为用户分配 mallory
“管理员”特权。
import json
import requests
from urllib.parse import urlparse
from urllib.parse import parse_qs
url = 'https://www.example.com/some_path?name=some_value'
parsed_url = urlparse(url)
untrusted_values = parse_qs(parsed_url.query)['name'][0]
with open('data.json', 'r') as json_File:
data = json.load(json_File)
data['name']= untrusted_values
with open('data.json', 'w') as json_File:
json.dump(data, json_File)
...
name
中不受信任的数据进行验证以转义与 JSON 相关的特殊字符。这使得用户可以任意插入 JSON 密钥,可能会改变序列化 JSON 的结构。在此示例中,如果非特权用户 mallory
将 ","role":"admin
附加到 URL 中的 name 参数,则 JSON 将变为:
{
"role":"user",
"username":"mallory",
"role":"admin"
}
usernameField
和 passwordField
序列化为 JSON:
...
let jsonString : String = "{\"username\":\"\(usernameField.text)\",\"password\":\"\(passwordField.text)\",\"role\":\"default\"}"
usernameField
和 passwordField
中不受信任的数据进行验证以转义与 JSON 相关的特殊字符。这样,用户就可以任意插入 JSON 密钥,可能会更改已序列化的 JSON 的结构。在本例中,如果非特权用户 mallory
(密码为 Evil123!
)在将 ","role":"admin
输入 usernameField
字段时将其附加到其用户名中,则最终 JSON 将为:
{
"username":"mallory",
"role":"admin",
"password":"Evil123!",
"role":"default"
}
NSDictionary
对象,其中 NSJSONSerialization.JSONObjectWithData:
如下所示:
var error: NSError?
var jsonData : NSDictionary = NSJSONSerialization.JSONObjectWithData(jsonString.dataUsingEncoding(NSUTF8StringEncoding), options: NSJSONReadingOptions.MutableContainers, error: &error) as NSDictionary
NSDictionary
对象中 username
、password
和 role
的最终值将分别为 mallory
、Evil123!
和 admin
。在没有进一步验证反序列化 JSON 值是否有效的情况下,应用程序会错误地为用户分配 mallory
“管理员”特权。
def searchUserDetails(key:String) = Action.async { implicit request =>
val user_json = getUserDataFor(user)
val value = (user_json \ key).get.as[String]
...
}
key
是可由用户控制的,恶意用户可以利用它来访问用户的密码,以及 JSON 文档中可能包含的任何其他私人数据。search
方法的 javax.naming.directory.SearchControls
实例的 returningObjectFlag
设置为 true
,或使用代表其设置此标志的库函数,执行对象返回搜索。
<beans ... >
<authentication-manager>
<ldap-authentication-provider
user-search-filter="(uid={0})"
user-search-base="ou=users,dc=example,dc=org"
group-search-filter="(uniqueMember={0})"
group-search-base="ou=groups,dc=example,dc=org"
group-role-attribute="cn"
role-prefix="ROLE_">
</ldap-authentication-provider>
</authentication-manager>
</beans>
...
DirectorySearcher src =
new DirectorySearcher("(manager=" + managerName.Text + ")");
src.SearchRoot = de;
src.SearchScope = SearchScope.Subtree;
foreach(SearchResult res in src.FindAll()) {
...
}
(manager=Smith, John)
managerName
不包含任何 LDAP 元字符时才能正常运行。如果攻击者为 managerName
输入字符串 Hacker, Wiley)(|(objectclass=*)
,则该查询会变成:
(manager=Hacker, Wiley)(|(objectclass=*))
|(objectclass=*)
条件会导致筛选器与目录中的所有输入都匹配,而且会使攻击者检索到有关用户输入池的信息。根据执行 LDAP 查询的权限大小,此次攻击的影响范围可能会有所差异,但是如果攻击者可以控制查询的命令结构,那么这样的攻击至少会影响执行 LDAP 查询的用户可以访问的所有记录。
fgets(manager, sizeof(manager), socket);
snprintf(filter, sizeof(filter, "(manager=%s)", manager);
if ( ( rc = ldap_search_ext_s( ld, FIND_DN, LDAP_SCOPE_BASE,
filter, NULL, 0, NULL, NULL, LDAP_NO_LIMIT,
LDAP_NO_LIMIT, &result ) ) == LDAP_SUCCESS ) {
...
}
(manager=Smith, John)
manager
不包含任何 LDAP 元字符时才能正常运行。如果攻击者为 manager
输入字符串 Hacker, Wiley)(|(objectclass=*)
,则该查询会变成:
(manager=Hacker, Wiley)(|(objectclass=*))
|(objectclass=*)
条件会导致筛选器与目录中的所有输入都匹配,而且会使攻击者检索到有关用户输入池的信息。根据执行 LDAP 查询的权限大小,此次攻击的影响范围可能会有所差异,但是如果攻击者可以控制查询的命令结构,那么这样的攻击至少会影响执行 LDAP 查询的用户可以访问的所有记录。
...
DirContext ctx = new InitialDirContext(env);
String managerName = request.getParameter("managerName");
//retrieve all of the employees who report to a manager
String filter = "(manager=" + managerName + ")";
NamingEnumeration employees = ctx.search("ou=People,dc=example,dc=com",
filter);
...
(manager=Smith, John)
managerName
不包含任何 LDAP 元字符时才能正常运行。如果攻击者为 managerName
输入字符串 Hacker, Wiley)(|(objectclass=*)
,则该查询会变成:
(manager=Hacker, Wiley)(|(objectclass=*))
|(objectclass=*)
条件会导致筛选器与目录中的所有输入都匹配,而且会使攻击者检索到有关用户输入池的信息。根据执行 LDAP 查询的权限大小,此次攻击的影响范围可能会有所差异,但是如果攻击者可以控制查询的命令结构,那么这样的攻击至少会影响执行 LDAP 查询的用户可以访问的所有记录。
...
$managerName = $_POST["managerName"]];
//retrieve all of the employees who report to a manager
$filter = "(manager=" . $managerName . ")";
$result = ldap_search($ds, "ou=People,dc=example,dc=com", $filter);
...
(manager=Smith, John)
managerName
不包含任何 LDAP 元字符时才能正常运行。如果攻击者为 managerName
输入字符串 Hacker, Wiley)(|(objectclass=*)
,则该查询会变成:
(manager=Hacker, Wiley)(|(objectclass=*))
|(objectclass=*)
条件会导致筛选器与目录中的所有输入都匹配,而且会使攻击者检索到有关用户输入池的信息。根据执行 LDAP 查询的权限大小,此次攻击的影响范围可能会有所差异,但是如果攻击者可以控制查询的命令结构,那么这样的攻击至少会影响执行 LDAP 查询的用户可以访问的所有记录。