Problemas de validação e representação da entrada são causados por metacaracteres, codificações alternativas e representações numéricas. Confiar na entrada resulta em problemas de segurança. Os problemas incluem: “Buffer Overflows”, ataques de “Cross-Site Scripting”, “SQL Injection”, entre outros.
username e password para o arquivo JSON localizado em C:\user_info.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(), os dados não confiáveis em username e password não serão validados para o escape de caracteres especiais relacionados ao JSON. Isso permite que um usuário insira chaves JSON arbitrariamente, possivelmente mudando a estrutura do JSON serializado. Neste exemplo, se o usuário não privilegiado mallory com a senha Evil123! fosse acrescentar ","role":"admin ao seu nome de usuário ao inseri-lo no prompt que define o valor da variável username, o JSON salvo em C:\user_info.json seria:
{
"role":"default",
"username":"mallory",
"role":"admin",
"password":"Evil123!"
}
Dictionary com JsonConvert.DeserializeObject(), da seguinte maneira:
String jsonString = File.ReadAllText(@"C:\user_info.json");
Dictionary<string, string> userInfo = JsonConvert.DeserializeObject<Dictionary<string, strin>>(jsonString);
username, password e role no objeto Dictionary seriam mallory, Evil123! e admin, respectivamente. Sem a verificação adicional de que os valores JSON desserializados são válidos, o aplicativo atribuirá incorretamente os privilégios "admin" ao usuário mallory.username e password para o arquivo JSON localizado em ~/user_info.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 e password não serão validados para realizar escape de caracteres especiais relacionados a JSON. Isso permite que um usuário insira chaves JSON arbitrárias, podendo modificar a estrutura serializada JSON. Neste exemplo, se o usuário não privilegiado mallory com a senha Evil123! anexou ","role":"admin quando ela inseriu seu nome de usuário, o JSON resultante salvo para ~/user_info.json seria:
{
"username":"mallory",
"role":"default",
"password":"Evil123!",
"role":"admin"
}
mallory.username e password para o arquivo JSON localizado em ~/user_info.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(), os dados não confiáveis em username e password não serão validados para o escape de caracteres especiais relacionados ao JSON. Isso permite que um usuário insira chaves JSON arbitrariamente, possivelmente mudando a estrutura do JSON serializado. Neste exemplo, se o usuário não privilegiado mallory com a senha Evil123! fosse acrescentar ","role":"admin ao seu nome de usuário ao inseri-lo no prompt que define o valor da variável username, o JSON salvo em ~/user_info.json seria:
{
"username":"mallory",
"role":"admin",
"password":"Evil123!",
"role":"default"
}
HashMap com JsonParser do Jackson, da seguinte maneira:
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();
username, password e role no objeto HashMap seriam mallory, Evil123! e admin, respectivamente. Sem a verificação adicional de que os valores JSON desserializados são válidos, o aplicativo atribuirá incorretamente os privilégios "admin" ao usuário 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 não serão validados para escapar dos caracteres especiais relacionadas com o JSON. Isso permite que um usuário insira chaves JSON arbitrariamente, possivelmente mudando a estrutura do JSON serializado. Neste exemplo, se o usuário não privilegiado mallory acrescentasse ","role":"admin ao parâmetro nome na URL, o JSON se tornaria:
{
"role":"user",
"username":"mallory",
"role":"admin"
}
jQuery.parseJSON() e definido como um objeto simples, o que significa que obj.role retornaria agora "admin" em vez de "user"_usernameField e _passwordField:
...
NSString * const jsonString = [NSString stringWithFormat: @"{\"username\":\"%@\",\"password\":\"%@\",\"role\":\"default\"}" _usernameField.text, _passwordField.text];
NSString.stringWithFormat:, os dados não confiáveis em _usernameField e _passwordField não serão validados para o escape de caracteres especiais relacionados ao JSON. Isso permite que um usuário insira chaves JSON arbitrariamente, possivelmente mudando a estrutura do JSON serializado. Nesse exemplo, se o usuário não privilegiado mallory com a senha Evil123! anexasse ","role":"admin ao nome de usuário dele ao digitá-lo no campo _usernameField, o JSON resultante seria:
{
"username":"mallory",
"role":"admin",
"password":"Evil123!",
"role":"default"
}
NSDictionary com NSJSONSerialization.JSONObjectWithData: desta maneira:
NSError *error;
NSDictionary *jsonData = [NSJSONSerialization JSONObjectWithData:[jsonString dataUsingEncoding:NSUTF8StringEncoding] options:NSJSONReadingAllowFragments error:&error];
username, password, e role no objeto NSDictionary seriam mallory, Evil123!, e admin respectivamente. Sem a verificação adicional de que os valores JSON desserializados são válidos, o aplicativo atribuirá incorretamente os privilégios "admin" ao usuário 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 não serão validados para aplicar o escape de caracteres especiais relacionados a JSON. Isso permite que um usuário insira chaves JSON arbitrariamente, possivelmente alterando a estrutura do JSON serializado. Nesse exemplo, se o usuário não privilegiado mallory anexasse ","role":"admin ao parâmetro name na URL, o JSON se tornaria:
{
"role":"user",
"username":"mallory",
"role":"admin"
}
usernameField e passwordField:
...
let jsonString : String = "{\"username\":\"\(usernameField.text)\",\"password\":\"\(passwordField.text)\",\"role\":\"default\"}"
usernameField e passwordField não serão validados para realizar escape dos caracteres especiais relacionados a JSON. Isso permite que um usuário insira chaves JSON arbitrariamente, possivelmente mudando a estrutura do JSON serializado. Nesse exemplo, se o usuário não privilegiado mallory com a senha Evil123! anexasse ","role":"admin ao nome de usuário dele ao digitá-lo no campo usernameField, o JSON resultante seria:
{
"username":"mallory",
"role":"admin",
"password":"Evil123!",
"role":"default"
}
NSDictionary com NSJSONSerialization.JSONObjectWithData: desta maneira:
var error: NSError?
var jsonData : NSDictionary = NSJSONSerialization.JSONObjectWithData(jsonString.dataUsingEncoding(NSUTF8StringEncoding), options: NSJSONReadingOptions.MutableContainers, error: &error) as NSDictionary
username, password, e role no objeto NSDictionary seriam mallory, Evil123!, e admin respectivamente. Sem a verificação adicional de que os valores JSON desserializados são válidos, o aplicativo atribuirá incorretamente os privilégios "admin" ao usuário mallory.