輸入驗證和表示法問題是由中繼字元、替代編碼和數值表示法引起的。信任輸入會導致安全問題。問題包括：「Buffer Overflows」、「Cross-Site Scripting」攻擊、「SQL Injection」及其他許多問題。
username 和 password 將非特殊權限使用者的使用者帳戶驗證資訊 (這類使用者具有「default」角色，而具特殊權限之使用者具有「admin」角色) 序列化為位於 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 的結構。在此範例中，如果密碼為 Evil123! 的非特殊權限使用者 mallory 在依設定 username 變數值的提示進行輸入時，將 ","role":"admin 附加至其使用者名稱，則產生並儲存到 C:\user_info.json 的 JSON 將會如下所示：
{
"role":"default",
"username":"mallory",
"role":"admin",
"password":"Evil123!"
}
JsonConvert.DeserializeObject() 還原序列化為 Dictionary 物件，如下所示：
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 值是否有效，應用程式將會錯誤指派「admin」權限給使用者 mallory。username 和 password 將非特殊權限使用者的使用者帳戶驗證資訊 (這類使用者具有「default」角色，而擁有特殊權限的使用者具有「admin」角色) 序列化為位於 ~/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 的結構。在此範例中，如果密碼為 Evil123! 的非特殊權限使用者 mallory 在輸入自己的使用者名稱時附加了 ","role":"admin，則產生並儲存至 ~/user_info.json 的 JSON 將會如下所示：
{
"username":"mallory",
"role":"default",
"password":"Evil123!",
"role":"admin"
}
mallory。username 和 password 將非特殊權限使用者的使用者帳戶驗證資訊 (這類使用者具有「default」角色，而具特殊權限之使用者具有「admin」角色) 序列化為位於 ~/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 的結構。在此範例中，如果密碼為 Evil123! 的非特殊權限使用者 mallory 在依設定 username 變數值的提示進行輸入時，將 ","role":"admin 附加至其使用者名稱，則產生並儲存到 ~/user_info.json 的 JSON 將會如下所示：
{
"username":"mallory",
"role":"admin",
"password":"Evil123!",
"role":"default"
}
JsonParser 還原序列化為 HashMap 物件，如下所示：
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 值是否有效，應用程式將會錯誤指派「admin」權限給使用者 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，將非特殊權限使用者的使用者帳戶驗證資訊 (這類使用者具有「default」角色，而具特殊權限之使用者具有「admin」角色) 序列化為 JSON：
...
NSString * const jsonString = [NSString stringWithFormat: @"{\"username\":\"%@\",\"password\":\"%@\",\"role\":\"default\"}" _usernameField.text, _passwordField.text];
NSString.stringWithFormat: 來執行的，所以將不會驗證 _usernameField 和 _passwordField 中的不可信賴資料以逸出與 JSON 相關的特殊字元。如此便允許使用者任意插入 JSON 金鑰，進而可能變更已序列化之 JSON 的結構。在此範例中，如果密碼為 Evil123! 的非特殊權限使用者 mallory 在輸入 _usernameField 欄位時，會將 ","role":"admin 附加至其使用者名稱，則產生的 JSON 將會如下所示：
{
"username":"mallory",
"role":"admin",
"password":"Evil123!",
"role":"default"
}
NSJSONSerialization.JSONObjectWithData: 還原序列化為 NSDictionary 物件，如下所示：
NSError *error;
NSDictionary *jsonData = [NSJSONSerialization JSONObjectWithData:[jsonString dataUsingEncoding:NSUTF8StringEncoding] options:NSJSONReadingAllowFragments error:&error];
NSDictionary 物件中產生的 username、password 和 role 值將分別是 mallory、Evil123! 和 admin。如果未進一步驗證還原序列化的 JSON 值是否有效，應用程式將會錯誤指派「admin」權限給使用者 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 中的名稱參數，JSON 會變成：
{
"role":"user",
"username":"mallory",
"role":"admin"
}
usernameField 和 passwordField，將非特殊權限使用者的使用者帳戶驗證資訊 (這類使用者具有「default」角色，而具特殊權限之使用者具有「admin」角色) 序列化為 JSON：
...
let jsonString : String = "{\"username\":\"\(usernameField.text)\",\"password\":\"\(passwordField.text)\",\"role\":\"default\"}"
usernameField 和 passwordField 中不受信任的資料以逸出與 JSON 相關的特殊字元。如此便允許使用者任意注入 JSON 金鑰，進而可能變更已序列化之 JSON 的結構。在此範例中，如果密碼為 Evil123! 的非特殊權限使用者 mallory 在輸入 usernameField 欄位時，會將 ","role":"admin 附加至其使用者名稱，則產生的 JSON 將會如下所示：
{
"username":"mallory",
"role":"admin",
"password":"Evil123!",
"role":"default"
}
NSJSONSerialization.JSONObjectWithData: 還原序列化為 NSDictionary 物件，如下所示：
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 值是否有效，應用程式將會錯誤指派「admin」權限給使用者 mallory。shoes：
<order>
<price>100.00</price>
<item>shoes</item>
</order>
shoes 取代 shoes</item><price>1.00</price><item>shoes。新的 XML 會變成：
<order>
<price>100.00</price>
<item>shoes</item><price>1.00</price><item>shoes</item>
</order>
<price> 的值會覆寫第一個 <price> 標籤的值。因此攻擊者將能以 1 美元購買一雙價值 100 美元的鞋子。shoes。
<order>
<price>100.00</price>
<item>shoes</item>
</order>
shoes 取代 shoes</item><price>1.00</price><item>shoes。新的 XML 會變成：
<order>
<price>100.00</price>
<item>shoes</item><price>1.00</price><item>shoes</item>
</order>
<price> 的值會覆寫第一個 <price> 標籤的值。因此攻擊者將能以 1 美元購買一雙價值 100 美元的鞋子。shoes。
<order>
<price>100.00</price>
<item>shoes</item>
</order>
shoes 取代 shoes</item><price>1.00</price><item>shoes。新的 XML 會變成：
<order>
<price>100.00</price>
<item>shoes</item><price>1.00</price><item>shoes</item>
</order>
<price> 的值會覆寫第一個 <price> 標籤的值。因此攻擊者將能以 1 美元購買一雙價值 100 美元的鞋子。shoes：
<order>
<price>100.00</price>
<item>shoes</item>
</order>
shoes 取代 shoes</item><price>1.00</price><item>shoes。新的 XML 會變成：
<order>
<price>100.00</price>
<item>shoes</item><price>1.00</price><item>shoes</item>
</order>
<price> 的值會覆寫第一個 <price> 標籤的值。因此攻擊者將能以 1 美元購買一雙價值 100 美元的鞋子。shoes。
<order>
<price>100.00</price>
<item>shoes</item>
</order>
shoes 取代 shoes</item><price>1.00</price><item>shoes。新的 XML 會變成：
<order>
<price>100.00</price>
<item>shoes</item><price>1.00</price><item>shoes</item>
</order>
<price> 的值會覆寫第一個 <price> 標籤的值。因此攻擊者將能以 1 美元購買一雙價值 100 美元的鞋子。shoes。
<order>
<price>100.00</price>
<item>shoes</item>
</order>
shoes 取代 shoes</item><price>1.00</price><item>shoes。新的 XML 會變成：
<order>
<price>100.00</price>
<item>shoes</item><price>1.00</price><item>shoes</item>
</order>
shoes。
<order>
<price>100.00</price>
<item>shoes</item>
</order>
shoes 取代 shoes</item><price>1.00</price><item>shoes。新的 XML 會變成：
<order>
<price>100.00</price>
<item>shoes</item><price>1.00</price><item>shoes</item>
</order>
<price> 的值會覆寫第一個 <price> 標籤的值。因此攻擊者將能以 1 美元購買一雙價值 100 美元的鞋子。shoes。
<order>
<price>100.00</price>
<item>shoes</item>
</order>
shoes 取代 shoes</item><price>1.00</price><item>shoes。新的 XML 會變成：
<order>
<price>100.00</price>
<item>shoes</item><price>1.00</price><item>shoes</item>
</order>
<price> 的值會覆寫第一個 <price> 標籤的值。因此攻擊者將能以 1 美元購買一雙價值 100 美元的鞋子。
...
<?php
$goodXML = $_GET["key"];
$doc = simplexml_load_string($goodXml);
echo $doc->testing;
?>
...
Example 2 中的程式碼：
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "file:///c:/boot.ini" >]><foo>&xxe;</foo>
boot.ini 檔案的內容。攻擊者可能利用傳回到用戶端的 XML 元素竊取資料或取得資訊，以便知道有哪些網路資源。shoes。
<order>
<price>100.00</price>
<item>shoes</item>
</order>
shoes 取代 shoes</item><price>1.00</price><item>shoes。新的 XML 會變成：
<order>
<price>100.00</price>
<item>shoes</item><price>1.00</price><item>shoes</item>
</order>
<price> 的值會覆寫第一個 <price> 標籤的值。因此攻擊者將能以 1 美元購買一雙價值 100 美元的鞋子。shoes。
<order>
<price>100.00</price>
<item>shoes</item>
</order>
shoes 取代 shoes</item><price>1.00</price><item>shoes。新的 XML 會變成：
<order>
<price>100.00</price>
<item>shoes</item><price>1.00</price><item>shoes</item>
</order>
<price> 的值會覆寫第一個 <price> 標籤的值。因此攻擊者將能以 1 美元購買一雙價值 100 美元的鞋子。shoes。
<order>
<price>100.00</price>
<item>shoes</item>
</order>
shoes 取代 shoes</item><price>1.00</price><item>shoes。新的 XML 會變成：
<order>
<price>100.00</price>
<item>shoes</item><price>1.00</price><item>shoes</item>
</order>
<price> 的值會覆寫第一個 <price> 標籤的值。因此攻擊者將能以 1 美元購買一雙價值 100 美元的鞋子。shoes。
<order>
<price>100.00</price>
<item>shoes</item>
</order>
shoes 取代 shoes</item><price>1.00</price><item>shoes。新的 XML 會變成：
<order>
<price>100.00</price>
<item>shoes</item><price>1.00</price><item>shoes</item>
</order>
<price> 的值會覆寫第一個 <price> 標籤的值。因此攻擊者將能以 1 美元購買一雙價值 100 美元的鞋子。a:t 標籤。
<a:t>YoY results: up 10%</a:t>