Los problemas de validación y representación de entradas están causados por metacaracteres, codificaciones alternativas y representaciones numéricas. Los problemas de seguridad surgen de entradas en las que se confía. Estos problemas incluyen: «desbordamientos de búfer», ataques de «scripts de sitios», "SQL injection" y muchas otras acciones.
...
v_account = request->get_form_field( 'account' ).
v_reference = request->get_form_field( 'ref_key' ).
CONCATENATE `user = '` sy-uname `'` INTO cl_where.
IF v_account IS NOT INITIAL.
CONCATENATE cl_where ` AND account = ` v_account INTO cl_where SEPARATED BY SPACE.
ENDIF.
IF v_reference IS NOT INITIAL.
CONCATENATE cl_where "AND ref_key = `" v_reference "`" INTO cl_where.
ENDIF.
SELECT *
FROM invoice_items
INTO CORRESPONDING FIELDS OF TABLE itab_items
WHERE (cl_where).
...
SELECT *
FROM invoice_items
INTO CORRESPONDING FIELDS OF TABLE itab_items
WHERE user = sy-uname
AND account = <account>
AND ref_key = <reference>.
"abc` OR MANDT NE `+"
para v_reference y la cadena '1000' para v_account, entonces la consulta será de la siguiente forma:
SELECT *
FROM invoice_items
INTO CORRESPONDING FIELDS OF TABLE itab_items
WHERE user = sy-uname
AND account = 1000
AND ref_key = `abc` OR MANDT NE `+`.
OR MANDT NE `+`
hace que la cláusula WHERE
se evalúe siempre como verdadera porque el campo de cliente nunca puede ser igual al literal +, de manera que la consulta se hace lógicamente equivalente a la consulta mucho más simple:
SELECT * FROM invoice_items
INTO CORRESPONDING FIELDS OF TABLE itab_items.
invoice_items
, independientemente del usuario especificado.
PARAMETERS: p_street TYPE string,
p_city TYPE string.
Data: v_sql TYPE string,
stmt TYPE REF TO CL_SQL_STATEMENT.
v_sql = "UPDATE EMP_TABLE SET ".
"Update employee address. Build the update statement with changed details
IF street NE p_street.
CONCATENATE v_sql "STREET = `" p_street "`".
ENDIF.
IF city NE p_city.
CONCATENATE v_sql "CITY = `" p_city "`".
ENDIF.
l_upd = stmt->execute_update( v_sql ).
"ABC` SALARY = `1000000"
para el parámetro p_street, la aplicación permite que la base de datos se actualice con el ascenso de salario.
...
var params:Object = LoaderInfo(this.root.loaderInfo).parameters;
var username:String = String(params["username"]);
var itemName:String = String(params["itemName"]);
var query:String = "SELECT * FROM items WHERE owner = " + username + " AND itemname = " + itemName;
stmt.sqlConnection = conn;
stmt.text = query;
stmt.execute();
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'; DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
owner
coincide con el nombre de usuario del usuario actualmente autenticado.
...
string userName = ctx.getAuthenticatedUserName();
string query = "SELECT * FROM items WHERE owner = '"
+ userName + "' AND itemname = '"
+ ItemName.Text + "'";
sda = new SqlDataAdapter(query, conn);
DataTable dt = new DataTable();
sda.Fill(dt);
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'); DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
Ejemplo 2:como alternativa, puede obtener un resultado similar con SQLite utilizando el siguiente código:
...
ctx.getAuthUserName(&userName); {
CString query = "SELECT * FROM items WHERE owner = '"
+ userName + "' AND itemname = '"
+ request.Lookup("item") + "'";
dbms.ExecuteSQL(query);
...
...
sprintf (sql, "SELECT * FROM items WHERE owner='%s' AND itemname='%s'", username, request.Lookup("item"));
printf("SQL to execute is: \n\t\t %s\n", sql);
rc = sqlite3_exec(db,sql, NULL,0, &err);
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'); DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
...
ACCEPT USER.
ACCEPT ITM.
MOVE "SELECT * FROM items WHERE owner = '" TO QUERY1.
MOVE "' AND itemname = '" TO QUERY2.
MOVE "'" TO QUERY3.
STRING
QUERY1, USER, QUERY2, ITM, QUERY3 DELIMITED BY SIZE
INTO QUERY
END-STRING.
EXEC SQL
EXECUTE IMMEDIATE :QUERY
END-EXEC.
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itm
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'; DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
...
<cfquery name="matchingItems" datasource="cfsnippets">
SELECT * FROM items
WHERE owner='#Form.userName#'
AND itemId=#Form.ID#
</cfquery>
...
SELECT * FROM items
WHERE owner = <userName>
AND itemId = <ID>;
Form.ID
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para Form.ID
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemId = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario hacker
introduce la cadena "hacker'); DELETE FROM items; --
" para Form.ID
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'hacker'
AND itemId = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'hacker'
AND itemId = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
...
final server = await HttpServer.bind('localhost', 18081);
server.listen((request) async {
final headers = request.headers;
final userName = headers.value('userName');
final itemName = headers.value('itemName');
final query = "SELECT * FROM items WHERE owner = '"
+ userName! + "' AND itemname = '"
+ itemName! + "'";
db.query(query);
}
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un atacante con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la siguiente consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'; DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
...
rawQuery := request.URL.Query()
username := rawQuery.Get("userName")
itemName := rawQuery.Get("itemName")
query := "SELECT * FROM items WHERE owner = " + username + " AND itemname = " + itemName + ";"
db.Exec(query)
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un atacante con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la siguiente consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'; DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un atacante escribe la cadena "name'; DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crean las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
...
String userName = ctx.getAuthenticatedUserName();
String itemName = request.getParameter("itemName");
String query = "SELECT * FROM items WHERE owner = '"
+ userName + "' AND itemname = '"
+ itemName + "'";
ResultSet rs = stmt.execute(query);
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'; DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
Example 1
a la plataforma Android.
...
PasswordAuthentication pa = authenticator.getPasswordAuthentication();
String userName = pa.getUserName();
String itemName = this.getIntent().getExtras().getString("itemName");
String query = "SELECT * FROM items WHERE owner = '"
+ userName + "' AND itemname = '"
+ itemName + "'";
SQLiteDatabase db = this.openOrCreateDatabase("DB", MODE_PRIVATE, null);
Cursor c = db.rawQuery(query, null);
...
...
var username = document.form.username.value;
var itemName = document.form.itemName.value;
var query = "SELECT * FROM items WHERE owner = " + username + " AND itemname = " + itemName + ";";
db.transaction(function (tx) {
tx.executeSql(query);
}
)
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'; DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
...
$userName = $_SESSION['userName'];
$itemName = $_POST['itemName'];
$query = "SELECT * FROM items WHERE owner = '$userName' AND itemname = '$itemName';";
$result = mysql_query($query);
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'; DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
procedure get_item (
itm_cv IN OUT ItmCurTyp,
usr in varchar2,
itm in varchar2)
is
open itm_cv for ' SELECT * FROM items WHERE ' ||
'owner = '''|| usr || '''' ||
' AND itemname = ''' || itm || '''';
end get_item;
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itm
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'; DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
...
userName = req.field('userName')
itemName = req.field('itemName')
query = "SELECT * FROM items WHERE owner = ' " + userName +" ' AND itemname = ' " + itemName +"';"
cursor.execute(query)
result = cursor.fetchall()
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'; DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
...
userName = getAuthenticatedUserName()
itemName = params[:itemName]
sqlQuery = "SELECT * FROM items WHERE owner = '#{userName}' AND itemname = '#{itemName}'"
rs = conn.query(sqlQuery)
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.
...
id = params[:id]
itemName = Mysql.escape_string(params[:itemName])
sqlQuery = "SELECT * FROM items WHERE id = #{userName} AND itemname = '#{itemName}'"
rs = conn.query(sqlQuery)
...
SELECT * FROM items WHERE id=<id> AND itemname = <itemName>;
itemName
aparentemente hemos evitado la vulnerabilidad de SQL Injection. Sin embargo, como Ruby no es un lenguaje estático, y a pesar de que esperamos que id
sea un entero de algún tipo, no tiene por qué ser necesariamente un número, ya que se asigna a partir de la entrada del usuario. Por lo tanto, si un usuario malintencionado logra cambiar el valor de id
a 1 OR id!=1--
, dado que no se comprueba si id
es realmente un número, la consulta SQL se convierte en:
SELECT * FROM items WHERE id=1 OR id!=1-- AND itemname = 'anyValue';
SELECT * FROM items WHERE id=1 OR id!=1;
id
es 1 o no, lo que por supuesto equivale a todo el contenido de la tabla.
def doSQLQuery(value:String) = Action.async { implicit request =>
val result: Future[Seq[User]] = db.run {
sql"select * from users where name = '#$value'".as[User]
}
...
}
SELECT * FROM users
WHERE name = <userName>
userName
no contiene un carácter de comilla simple. Si un atacante con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para userName
, la consulta se convertirá en lo siguiente:
SELECT * FROM users
WHERE name = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la siguiente consulta más simple:
SELECT * FROM users;
users
, independientemente del usuario especificado.owner
coincide con el nombre de usuario del usuario autenticado actualmente.
...
let queryStatementString = "SELECT * FROM items WHERE owner='\(username)' AND itemname='\(item)'"
var queryStatement: OpaquePointer? = nil
if sqlite3_prepare_v2(db, queryStatementString, -1, &queryStatement, nil) == SQLITE_OK {
if sqlite3_step(queryStatement) == SQLITE_ROW {
...
}
}
...
SELECT * FROM items
WHERE owner = '<userName>'
AND itemname = '<itemName>'
itemName
no contiene un carácter de comilla simple. Si un atacante con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la siguiente consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'); DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
...
username = Session("username")
itemName = Request.Form("itemName")
strSQL = "SELECT * FROM items WHERE owner = '"& userName &"' AND itemname = '" & itemName &"'"
objRecordSet.Open strSQL, strConnect, adOpenDynamic, adLockOptimistic, adCmdText
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'; DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
owner
coincide con el nombre de usuario del usuario actualmente autenticado.
...
string userName = ctx.getAuthenticatedUserName();
string queryString = "SELECT * FROM items WHERE owner = '"
+ userName + "' AND itemname = '"
+ ItemName.Text + "'";
SimpleQuery<Item> queryObject = new SimpleQuery(queryString);
Item[] items = (Item[])queryObject.Execute(query);
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.
...
String userName = ctx.getAuthenticatedUserName();
String itemName = request.getParameter("itemName");
String query = "FROM items WHERE owner = '"
+ userName + "' AND itemname = '"
+ itemName + "'";
List items = sess.createQuery(query).list();
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'; DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
#
, de este modo:
<select id="getItems" parameterClass="MyClass" resultClass="items">
SELECT * FROM items WHERE owner = #userName#
</select>
#
alrededor del nombre de la variable indican que iBatis creará una consulta parametrizada con la variable userName
. Sin embargo, iBatis también le permite concatenar variables directamente con instrucciones SQL usando caracteres $
, lo que abre la puerta a la SQL Injection.
<select id="getItems" parameterClass="MyClass" resultClass="items">
SELECT * FROM items WHERE owner = #userName# AND itemname = '$itemName$'
</select>
itemName
no contiene un carácter de comilla simple. Si un atacante con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la siguiente consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'; DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
...
String userName = ctx.getAuthenticatedUserName();
String itemName = request.getParameter("itemName");
String sql = "SELECT * FROM items WHERE owner = '"
+ userName + "' AND itemname = '"
+ itemName + "'";
Query query = pm.newQuery(Query.SQL, sql);
query.setClass(Person.class);
List people = (List)query.execute();
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'; DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
owner
coincide con el nombre de usuario del usuario actualmente autenticado.
...
string userName = ctx.getAuthenticatedUserName();
string query = "SELECT * FROM items WHERE owner = '"
+ userName + "' AND itemname = '"
+ ItemName.Text + "'";
var items = dataContext.ExecuteCommand<Item>(query);
...
SELECT * FROM items
WHERE owner = <userName>
AND itemname = <itemName>;
itemName
no contiene un carácter de comilla simple. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula where siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la consulta más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'); DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';
#
, de este modo:
<select id="getItems" parameterType="domain.company.MyParamClass" resultType="MyResultMap">
SELECT *
FROM items
WHERE owner = #{userName}
</select>
#
con llaves alrededor del nombre de la variable indica que MyBatis creará una consulta parametrizada con la variable userName
. Sin embargo, MyBatis también le permite concatenar variables directamente con instrucciones SQL usando el carácter $
, lo que abre la puerta a la SQL Injection.
<select id="getItems" parameterType="domain.company.MyParamClass" resultType="MyResultMap">
SELECT *
FROM items
WHERE owner = #{userName}
AND itemname = ${itemName}
</select>
itemName
no contiene un carácter de comilla simple. Si un atacante con el nombre de usuario wiley
introduce la cadena "name' OR 'a'='a
" para itemName
, la consulta se convertirá en lo siguiente:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name' OR 'a'='a';
OR 'a'='a'
hace que la cláusula WHERE
siempre se evalúe como true, por lo que lógicamente la consulta pasará a ser equivalente a la siguiente consulta mucho más simple:
SELECT * FROM items;
items
, independientemente del propietario especificado.Example 1
. Si un usuario malintencionado con el nombre de usuario wiley
introduce la cadena "name'; DELETE FROM items; --
" para itemName
, la consulta se convertirá en las dos consultas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
--'
Example 1
. Si un usuario malintencionado escribe la cadena "name'); DELETE FROM items; SELECT * FROM items WHERE 'a'='a
", se crearán las tres instrucciones válidas siguientes:
SELECT * FROM items
WHERE owner = 'wiley'
AND itemname = 'name';
DELETE FROM items;
SELECT * FROM items WHERE 'a'='a';