@GetMapping("/prompt_injection_persistent")
String generation(String userInput1, ...) {
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users WHERE ...");
String userName = "";
if (rs != null) {
rs.next();
userName = rs.getString("userName");
}
return this.clientBuilder.build().prompt()
.system("Assist the user " + userName)
.user(userInput1)
.call()
.content();
}
client = new Anthropic();
# Simulated attacker's input attempting to inject a malicious system prompt
attacker_query = ...;
attacker_name = db.qyery('SELECT name FROM user_profiles WHERE ...');
response = client.messages.create(
model = "claude-3-5-sonnet-20240620",
max_tokens=2048,
system = "Provide assistance to the user " + attacker_name,
messages = [
{"role": "user", "content": attacker_query}
]
);
...
client = OpenAI()
# Simulated attacker's input attempting to inject a malicious system prompt
attacker_name = cursor.fetchone()['name']
attacker_query = ...
completion = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "Provide assistance to the user " + attacker_name},
{"role": "user", "content": attacker_query}
]
)
select() 查询，该查询可搜索与用户指定产品类别相匹配的清单。用户还可以指定对结果进行排序的列。假定在执行此代码片段之前已正确验证了应用程序并设置了 customerID 的值。
...
String customerID = getAuthenticatedCustomerID(customerName, customerCredentials);
...
AmazonSimpleDBClient sdbc = new AmazonSimpleDBClient(appAWSCredentials);
String query = "select * from invoices where productCategory = '"
+ productCategory + "' and customerID = '"
+ customerID + "' order by '"
+ sortColumn + "' asc";
SelectResult sdbResult = sdbc.select(new SelectRequest(query));
...
select * from invoices
where productCategory = 'Fax Machines'
and customerID = '12345678'
order by 'price' asc
productCategory 和 price 不包含单引号字符时，才会正确执行这一查询。但是，如果攻击者为 productCategory 提供了字符串“Fax Machines' or productCategory = \"”，并为 sortColumn 提供了字符串“\" order by 'price”，则查询将变为如下所示：
select * from invoices
where productCategory = 'Fax Machines' or productCategory = "'
and customerID = '12345678'
order by '" order by 'price' asc
select * from invoices
where productCategory = 'Fax Machines'
or productCategory = "' and customerID = '12345678' order by '"
order by 'price' asc
customerID 所要求的 Authentication，并查看与 'Fax Machines' 相匹配的所有客户清单记录。customerID 的值。
...
productCategory = this.getIntent().getExtras().getString("productCategory");
sortColumn = this.getIntent().getExtras().getString("sortColumn");
customerID = getAuthenticatedCustomerID(customerName, customerCredentials);
c = invoicesDB.query(Uri.parse(invoices), columns, "productCategory = '" + productCategory + "' and customerID = '" + customerID + "'", null, null, null, "'" + sortColumn + "'asc", null);
...
select * from invoices
where productCategory = 'Fax Machines'
and customerID = '12345678'
order by 'price' asc
productCategory 连在一起形成。因此只有在 productCategory 与 sortColumn 不包含单引号字符时，这一查询才能正确执行。如果攻击者为 productCategory 提供了字符串“Fax Machines' or productCategory = \"”，并为 sortColumn 提供了字符串“\" order by 'price”，则查询将变为如下所示：
select * from invoices
where productCategory = 'Fax Machines' or productCategory = "'
and customerID = '12345678'
order by '" order by 'price' asc
select * from invoices
where productCategory = 'Fax Machines'
or productCategory = "' and customerID = '12345678' order by '"
order by 'price' asc
customerID 所要求的 authentication，并查看与 'Fax Machines' 相匹配的所有客户清单记录。
Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setDataAndType(Uri.fromFile(new File(Environment.getExternalStorageDirectory() + "/download/" + "app.apk")), "application/vnd.android.package-archive");
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
...
public class Box{
public int area;
public static final int width = 10;
public static final Box box = new Box();
public static final int height = (int) (Math.random() * 100);
public Box(){
area = width * height;
}
...
}
...
Example 1 中，由于 width 等于 10，因此开发人员希望 box.area 是一个随机整数，该整数恰好为 10 的倍数。但在现实情况中，它可能始终具有硬编码值 0。系统首先会对使用编译时常量声明的静态最终字段进行初始化，然后依次执行各个代码。这意味着，由于 height 不是编译时常量，因此会在声明 box 后对其进行声明，这样就会在初始化 height 字段之前调用构造函数。
...
class Foo{
public static final int f = Bar.b - 1;
...
}
...
class Bar{
public static final int b = Foo.f + 1;
...
}
This example is perhaps easier to identify, but would be dependent on which class is loaded first by the JVM. In this exampleFoo.fcould be either -1 or 0, andBar.bcould be either 0 or 1.
java.text.Format 中的 parse() 和 format() 方法包含一个可导致用户看到其他用户数据的设计缺陷。java.text.Format 中的 parse() 和 format() 方法包含一个可导致用户看到其他用户数据的 race condition。
public class Common {
private static SimpleDateFormat dateFormat;
...
public String format(Date date) {
return dateFormat.format(date);
}
...
final OtherClass dateFormatAccess=new OtherClass();
...
public void function_running_in_thread1(){
System.out.println("Time in thread 1 should be 12/31/69 4:00 PM, found: "+ dateFormatAccess.format(new Date(0)));
}
public void function_running_in_thread2(){
System.out.println("Time in thread 2 should be around 12/29/09 6:26 AM, found: "+ dateFormatAccess.format(new Date(System.currentTimeMillis())));
}
}
format() 中存在 race condition。
public class GuestBook extends HttpServlet {
String name;
protected void doPost (HttpServletRequest req, HttpServletResponse res) {
name = req.getParameter("name");
...
out.println(name + ", thanks for visiting!");
}
}
Dick”分配给 nameJane”分配给 nameJane, thanks for visiting!”Jane, thanks for visiting!”
public class ConnectionManager {
private static Connection conn = initDbConn();
...
}
null 的指针是否为 null 之前间接引用该指针，则会发生 check-after-dereference 错误。如果程序明确检查过 null，并确定该指针为 null，但仍继续间接引用该指针，则会出现 dereference-after-check 错误。此类错误通常是由于错别字或程序员疏忽造成的。如果程序明确将指针设置为 null，但稍后却间接引用该指针，则将出现 dereference-after-store 错误。此错误通常是因为程序员在声明变量时将该变量初始化为 null 所致。foo 为 null，然后错误地对其进行间接引用。如果在 if 语句中检查 foo 时其为 null，则会发生 null 间接引用，从而导致 null 指针异常。示例 2：在下列代码中，程序员假设变量
if (foo is null) {
foo.SetBar(val);
...
}
foo 不是 null，并通过间接引用该对象来确认此假设。但是，程序员稍后通过检查 foo 是否为 null 发现事实与该假设相反。如果在 if 指令中检查时发现 foo 可能是 null，则在间接引用它时可能也为 null，并可能引起 null 指针异常。间接引用不安全，或者无需后续检查。示例 3：在下列代码中，程序员会将变量
foo.SetBar(val);
...
if (foo is not null) {
...
}
foo 明确设置为 null。之后，程序员会间接引用 foo，而未检查对象是否为 null 值。
Foo foo = null;
...
foo.SetBar(val);
...
}
null 的指针是否为 null 之前间接引用该指针，则会发生 check-after-dereference 错误。如果程序明确检查过 null，并确定该指针为 null，但仍继续间接引用该指针，则会出现 dereference-after-check 错误。此类错误通常是由于错别字或程序员疏忽造成的。如果程序明确将指针设置为 null，但稍后却间接引用该指针，则将出现 dereference-after-store 错误。此错误通常是因为程序员在声明变量时将该变量初始化为 null 所致。ptr 不是 NULL。当程序员间接引用该指针时，这个假设就会清晰的体现出来。当程序员检查 ptr 是否为 NULL 时，就会与该假设发生矛盾。当在 if 语句中检查时，如果 ptr 可以为 NULL，则在其间接引用时也将为 NULL，并引起 segmentation fault。示例 2：在下列代码中，程序员会确认变量
ptr->field = val;
...
if (ptr != NULL) {
...
}
ptr 为 NULL，然后错误地对其进行间接引用。如果在 if 语句中检查 ptr 时其为 NULL，则会发生 null dereference，从而导致分段故障。示例 3：在下列代码中，程序员忘记了字符串
if (ptr == null) {
ptr->field = val;
...
}
'\0' 实际上为 0 还是 NULL，从而间接引用 null 指针并引发分段故障。示例 4：在下列代码中，程序员会将变量
if (ptr == '\0') {
*ptr = val;
...
}
ptr 明确设置为 NULL。之后，程序员会间接引用 ptr，而未检查对象是否为 null 值。
*ptr = NULL;
...
ptr->field = val;
...
}
null，并确定该指针为 null，但仍继续间接引用该对象，则会出现 dereference-after-check 错误。此类错误通常是由于错别字或程序员疏忽造成的。foo 为 null，然后错误地对其进行间接引用。如果在 if 语句中检查 foo 时其为 null，则会发生 null dereference，从而导致 null 指针异常。
if (foo == null) {
foo.setBar(val);
...
}
Content-Disposition 标头配置错误，攻击者可以控制 HTTP 响应的 Content-Type 和/或 Content-Disposition 标头，或者目标应用程序包含 Content-Type（默认不会在浏览器中呈现）。ContentNegotiationManager 动态生成不同的响应格式，则满足发动 RFD 攻击的必要条件。ContentNegotiationManager 配置为根据请求路径扩展决定响应格式，使用 Java Activation Framework (JAF) 查找与客户端请求格式更匹配的 Content-Type。同时，客户端也可以通过请求的 Accept 标头中发送的媒体类型来指定响应内容类型。示例 2：在以下示例中，应用程序配置为允许通过请求的
<bean id="contentNegotiationManager" class="org.springframework.web.accept.ContentNegotiationManagerFactoryBean">
<property name="favorPathExtension" value="true" />
<property name="useJaf" value="true" />
</bean>
Accept 标头确定响应内容类型：
<bean id="contentNegotiationManager" class="org.springframework.web.accept.ContentNegotiationManagerFactoryBean">
<property name="ignoreAcceptHeader" value="false" />
</bean>
ContentNegotiationManagerFactoryBean 属性默认值为：useJaf：truefavorPathExtension：trueignoreAcceptHeader：falseExample 1 中所示的配置允许攻击者创建一个恶意 URL，例如：ContentNegotiationManager 将使用 Java Activation Framework（如果在类路径中发现 activation.jar）尝试解析给定文件扩展名的媒体类型，并相应设置响应的 ContentType 标头。在此示例中，文件扩展名是“bat”，进而生成 application/x-msdownload 的 Content-Type 标头（尽管实际 Content-Type 可能因服务器 OS 和 JAF 配置而异）。因此，一旦受害者访问此恶意 URL，他/她的计算机将自动开始下载包含攻击者控制内容的“.bat”文件。如果随后执行此文件，受害者计算机将运行攻击者有效负载指定的任何命令。
...
host_name = request->get_form_field( 'host' ).
CALL FUNCTION 'FTP_CONNECT'
EXPORTING
USER = user
PASSWORD = password
HOST = host_name
RFC_DESTINATION = 'SAPFTP'
IMPORTING
HANDLE = mi_handle
EXCEPTIONS
NOT_CONNECTED = 1
OTHERS = 2.
...
int rPort = Int32.Parse(Request.Item("rPort"));
...
IPEndPoint endpoint = new IPEndPoint(address,rPort);
socket = new Socket(endpoint.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
socket.Connect(endpoint);
...
...
char* rPort = getenv("rPort");
...
serv_addr.sin_port = htons(atoi(rPort));
if (connect(sockfd,&serv_addr,sizeof(serv_addr)) < 0)
error("ERROR connecting");
...
...
ACCEPT QNAME.
EXEC CICS
READQ TD
QUEUE(QNAME)
INTO(DATA)
LENGTH(LDATA)
END-EXEC.
...
ServerSocket 对象，并使用读取自 HTTP 请求的端口号来建立一个套接字。
<cfobject action="create" type="java" class="java.net.ServerSocket" name="myObj">
<cfset srvr = myObj.init(#url.port#)>
<cfset socket = srvr.accept()>
Passing user input to objects imported from other languages can be very dangerous.
final server = await HttpServer.bind('localhost', 18081);
server.listen((request) async {
final remotePort = headers.value('port');
final serverSocket = await ServerSocket.bind(host, remotePort as int);
final httpServer = HttpServer.listenOn(serverSocket);
});
...
func someHandler(w http.ResponseWriter, r *http.Request){
r.parseForm()
deviceName := r.FormValue("device")
...
syscall.BindToDevice(fd, deviceName)
}
String remotePort = request.getParameter("remotePort");
...
ServerSocket srvr = new ServerSocket(remotePort);
Socket skt = srvr.accept();
...
WebView 中加载页面。
...
WebView webview = new WebView(this);
setContentView(webview);
String url = this.getIntent().getExtras().getString("url");
webview.loadUrl(url);
...
var socket = new WebSocket(document.URL.indexOf("url=")+20);
...
char* rHost = getenv("host");
...
CFReadStreamRef readStream;
CFWriteStreamRef writeStream;
CFStreamCreatePairWithSocketToHost(NULL, (CFStringRef)rHost, 80, &readStream, &writeStream);
...
<?php
$host=$_GET['host'];
$dbconn = pg_connect("host=$host port=1234 dbname=ticketdb");
...
$result = pg_prepare($dbconn, "my_query", 'SELECT * FROM pricelist WHERE name = $1');
$result = pg_execute($dbconn, "my_query", array("ticket"));
?>
...
filename := SUBSTR(OWA_UTIL.get_cgi_env('PATH_INFO'), 2);
WPG_DOCLOAD.download_file(filename);
...
host=request.GET['host']
dbconn = db.connect(host=host, port=1234, dbname=ticketdb)
c = dbconn.cursor()
...
result = c.execute('SELECT * FROM pricelist')
...
def controllerMethod = Action { request =>
val result = request.getQueryString("key").map { key =>
val user = db.getUser()
cache.set(key, user)
Ok("Cached Request")
}
Ok("Done")
}
...
func application(app: UIApplication, openURL url: NSURL, options: [String : AnyObject]) -> Bool {
var inputStream : NSInputStream?
var outputStream : NSOutputStream?
...
var readStream : Unmanaged<CFReadStream>?
var writeStream : Unmanaged<CFWriteStream>?
let rHost = getQueryStringParameter(url.absoluteString, "host")
CFStreamCreatePairWithSocketToHost(kCFAllocatorDefault, rHost, 80, &readStream, &writeStream);
...
}
func getQueryStringParameter(url: String?, param: String) -> String? {
if let url = url, urlComponents = NSURLComponents(string: url), queryItems = (urlComponents.queryItems as? [NSURLQueryItem]) {
return queryItems.filter({ (item) in item.name == param }).first?.value!
}
return nil
}
...
...
Begin MSWinsockLib.Winsock tcpServer
...
Dim Response As Response
Dim Request As Request
Dim Session As Session
Dim Application As Application
Dim Server As Server
Dim Port As Variant
Set Response = objContext("Response")
Set Request = objContext("Request")
Set Session = objContext("Session")
Set Application = objContext("Application")
Set Server = objContext("Server")
Set Port = Request.Form("port")
...
tcpServer.LocalPort = Port
tcpServer.Accept
...
@ControllerAdvice
public class JsonpAdvice extends AbstractJsonpResponseBodyAdvice {
public JsonpAdvice() {
super("callback");
}
}
GET /api/latest.json?callback=myCallbackFunction 等请求，控制器方法将生成如下响应：
HTTP/1.1 200 Ok
Content-Type: application/json; charset=utf-8
Date: Tue, 12 Dec 2017 16:16:04 GMT
Server: nginx/1.12.1
Content-Length: 225
Connection: Close
myCallbackFunction({<json>})
Script 标记从 JSONP 端点加载该响应，从而转变为执行 myCallbackFunction 函数。 攻击者可以使用其他回调名称导航 DOM 并与其交互。 例如，opener.document.body.someElemnt.firstChild.nextElementSibling.submit 可用于查找目标页面中的表格并进行提交。
def myJSONPService(callback: String) = Action {
val json = getJSONToBeReturned()
Ok(Jsonp(callback, json))
}
GET /api/latest.json?callback=myCallbackFunction 等请求，Example 1 中所述的控制器方法将生成如下响应：
HTTP/1.1 200 Ok
Content-Type: application/json; charset=utf-8
Date: Tue, 12 Dec 2017 16:16:04 GMT
Server: nginx/1.12.1
Content-Length: 225
Connection: Close
myCallbackFunction({<json>})
Script 标记从 JSONP 端点加载该响应，从而转变为执行 myCallbackFunction 函数。 攻击者可以使用其他回调名称导航 DOM 并与其交互。 例如，opener.document.body.someElemnt.firstChild.nextElementSibling.submit 可用于查找目标页面中的表格并进行提交。
...
lv_uri = request->get_form_field( 'uri' ).
CALL METHOD cl_http_utility=>set_request_uri
EXPORTING
request = lo_request
uri = lv_uri.
...
http 或 https 的协议，类似于下面这样：
...
PageReference ref = ApexPages.currentPage();
Map<String,String> params = ref.getParameters();
HttpRequest req = new HttpRequest();
req.setEndpoint(params.get('url'));
HTTPResponse res = new Http().send(req);
http 或 https 的协议，类似于下面这样：
string url = Request.Form["url"];
HttpClient client = new HttpClient();
HttpResponseMessage response = await client.GetAsync(url);
http 或 https 的协议，类似于下面这样：
char *url = maliciousInput();
CURL *curl = curl_easy_init();
curl_easy_setopt(curl, CURLOPT_URL, url);
CURLcode res = curl_easy_perform(curl);
http 或 https 的协议，类似于下面这样：
...
final server = await HttpServer.bind('localhost', 18081);
server.listen((request) async {
final headers = request.headers;
final url = headers.value('url');
final client = IOClient();
final response = await client.get(Uri.parse(url!));
...
}
http 或 https 的协议，类似于下面这样：
url := request.Form.Get("url")
res, err =: http.Get(url)
...
http 或 https 的协议，类似于下面这样：
String url = request.getParameter("url");
CloseableHttpClient httpclient = HttpClients.createDefault();
HttpGet httpGet = new HttpGet(url);
CloseableHttpResponse response1 = httpclient.execute(httpGet);
http 或 https 的协议，类似于下面这样：
var http = require('http');
var url = require('url');
function listener(request, response){
var request_url = url.parse(request.url, true)['query']['url'];
http.request(request_url)
...
}
...
http.createServer(listener).listen(8080);
...
http 或 https 的协议，类似于下面这样：
val url: String = request.getParameter("url")
val httpclient: CloseableHttpClient = HttpClients.createDefault()
val httpGet = HttpGet(url)
val response1: CloseableHttpResponse = httpclient.execute(httpGet)
http 或 https 的协议，类似于下面这样：
$url = $_GET['url'];
$c = curl_init();
curl_setopt($c, CURLOPT_POST, 0);
curl_setopt($c,CURLOPT_URL,$url);
$response=curl_exec($c);
curl_close($c);
http 或 https 的协议，类似于下面这样：
url = request.GET['url']
handle = urllib.urlopen(url)
http 或 https 的协议，类似于下面这样：
url = req['url']
Net::HTTP.get(url)
http 或 https 的协议，类似于下面这样：
def getFile(url: String) = Action { request =>
...
val url = request.body.asText.getOrElse("http://google.com")
ws.url(url).get().map { response =>
Ok(s"Request sent to $url")
}
...
}
http 或 https 的协议，类似于下面这样：
// Set up the context data
VelocityContext context = new VelocityContext();
context.put( "name", user.name );
// Load the template
String template = getUserTemplateFromRequestBody(request);
RuntimeServices runtimeServices = RuntimeSingleton.getRuntimeServices();
StringReader reader = new StringReader(template);
SimpleNode node = runtimeServices.parse(reader, "myTemplate");
template = new Template();
template.setRuntimeServices(runtimeServices);
template.setData(node);
template.initDocument();
// Render the template with the context data
StringWriter sw = new StringWriter();
template.merge( context, sw );
Example 1 使用 Velocity 作为模板引擎。对于该引擎，攻击者可以提交以下模板以在服务器上运行任意命令：
$name.getClass().forName("java.lang.Runtime").getRuntime().exec(<COMMAND>)
app.get('/', function(req, res){
var template = _.template(req.params['template']);
res.write("<html><body><h2>Hello World!</h2>" + template() + "</body></html>");
});
Example 1 会使用 Underscore.js 作为 Node.js 应用程序中的模板引擎。对于该引擎，攻击者可以提交以下模板以在服务器上运行任意命令：
<% cp = process.mainModule.require('child_process');cp.exec(<COMMAND>); %>
Jinja2 模板引擎呈现该模板。
from django.http import HttpResponse
from jinja2 import Template as Jinja2_Template
from jinja2 import Environment, DictLoader, escape
def process_request(request):
# Load the template
template = request.GET['template']
t = Jinja2_Template(template)
name = source(request.GET['name'])
# Render the template with the context data
html = t.render(name=escape(name))
return HttpResponse(html)
Example 1 使用 Jinja2 作为模板引擎。对于该引擎，攻击者可以提交以下模板以从服务器中读取任意文件：示例 2：以下示例显示了如何从 HTTP 请求中检索模板并使用
template={{''.__class__.__mro__[2].__subclasses__()[40]('/etc/passwd').read()}}
Django 模板引擎呈现该模板。
from django.http import HttpResponse
from django.template import Template, Context, Engine
def process_request(request):
# Load the template
template = source(request.GET['template'])
t = Template(template)
user = {"name": "John", "secret":getToken()}
ctx = Context(locals())
html = t.render(ctx)
return HttpResponse(html)
Example 2 使用 Django 作为模板引擎。对于该引擎，攻击者将无法执行任意命令，但他们能够访问模板上下文中的所有对象。在此示例中，上下文中存在密钥标记，该密钥标记可能会被攻击者泄露。
<http auto-config="true">
...
<session-management session-fixation-protection="none"/>
</http>
Example 1 中，攻击者使用直接明显的方法并不高明，对于攻击不太出名的网站并不适用。然而，千万不要麻痹大意，攻击者有许多手段可以帮助他们避免上述攻击的局限性。攻击者最常用的技术包括：利用目标站点中的 Cross-Site Scripting 或者 HTTP Response Splitting 漏洞 [1]。攻击者诱使受害者向易受攻击的应用程序提交恶意请求，应用程序将相应的 JavaScript 或者其他代码返回到受害者的浏览器，借助于这种方式，攻击者便可以创建一个 Cookie，使受害者重新使用已受攻击者控制的会话标识符。bank.example.com 和 recipes.example.com），其中一个应用程序存在漏洞，则攻击者可以通过此漏洞设置一个 Cookie，并在其中包含一个已被修改的会话标识符，且该会话标识符可以在与 example.com [2] 域中所有应用程序的交互中使用。use_strict_mode 属性。
ini_set("session.use_strict_mode", "0");
@SessionAttributes 标注的类意味着，Spring 会将更改复制到会话对象中的模型属性。如果攻击者能够在模型属性中存储任意值，这些更改将在会话对象中复制，并可能得到应用程序信任。如果会话属性使用用户应当无法修改的可信赖数据进行初始化，攻击者则能够实施 Session Puzzling 攻击，滥用应用程序逻辑。
@Controller
@SessionAttributes("user")
public class HomeController {
...
@RequestMapping(value= "/auth", method=RequestMethod.POST)
public String authHandler(@RequestParam String username, @RequestParam String password, RedirectAttributes attributes, Model model) {
User user = userService.findByNamePassword(username, password);
if (user == null) {
// Handle error
...
} else {
// Handle success
attributes.addFlashAttribute("user", user);
return "redirect:home";
}
}
...
}
User 实例，因为此类使用 @SessionAttributes("user") 标注，并使用它来验证密码重置问题。
@Controller
@SessionAttributes("user")
public class ResetPasswordController {
@RequestMapping(value = "/resetQuestion", method = RequestMethod.POST)
public String resetQuestionHandler(@RequestParam String answerReset, SessionStatus status, User user, Model model) {
if (!user.getAnswer().equals(answerReset)) {
// Handle error
...
} else {
// Handle success
...
}
}
}
user 实例，此会话是在登录过程中存储实例的位置。然而，Spring 将检查请求，并且尝试将其数据绑定到模型 user 实例。如果接收的请求包含可绑定到 User 类的数据，Spring 会将接收的数据合并到用户会话属性中。通过在 answerReset 查询参数中提交任意答案并提交相同值覆盖会话中存储的值，可以滥用这种情况。这样，攻击者可以为随机用户设置任意新密码。
...
taintedConnectionStr = request->get_form_field( 'dbconn_name' ).
TRY.
DATA(con) = cl_sql_connection=>get_connection( `R/3*` && taintedConnectionStr ).
...
con->close( ).
CATCH cx_sql_exception INTO FINAL(exc).
...
ENDTRY.
...
sethostid(argv[1]);
...
sethostid()，但是未被赋予权限的用户也可能会调用这个程序。这个例子中的代码允许用户输入直接控制系统设置的值。如果攻击者为主机 ID 提供一个恶意值，攻击者会错误地识别网络上受影响的机器或者引发其他一些意料之外的行为。
...
ACCEPT OPT1.
ACCEPT OPT2
COMPUTE OPTS = OPT1 + OPT2.
CALL 'MQOPEN' USING HCONN, OBJECTDESC, OPTS, HOBJ, COMPOCODE REASON.
...
...
<cfset code = SetProfileString(IniPath,
Section, "timeout", Form.newTimeout)>
...
Form.newTimeout 的值用于指定超时时间，因此攻击者可以通过指定一个超大数值来发起 denial of service (DoS)，从而破坏应用程序的正常运行。
...
catalog := request.Form.Get("catalog")
path := request.Form.Get("path")
os.Setenv(catalog, path)
...
HttpServletRequest 中读取一个字符串，并将该字符串设置为数据库 Connection 中的当前目录。
...
conn.setCatalog(request.getParamter("catalog"));
...
http.IncomingMessage 请求变量中读取字符串，并使用该字符串设置其他 V8 命令行标记。
var v8 = require('v8');
...
var flags = url.parse(request.url, true)['query']['flags'];
...
v8.setFlagsFromString(flags);
...
<?php
...
$table_name=$_GET['catalog'];
$retrieved_array = pg_copy_to($db_connection, $table_name);
...
?>
...
catalog = request.GET['catalog']
path = request.GET['path']
os.putenv(catalog, path)
...
Connection 的当前目录。
def connect(catalog: String) = Action { request =>
...
conn.setCatalog(catalog)
...
}
...
sqlite3(SQLITE_CONFIG_LOG, user_controllable);
...
Request 对象中读取一个字符串，并将该字符串设置为数据库 Connection 中的当前目录。
...
Dim conn As ADODB.Connection
Set conn = New ADODB.Connection
Dim rsTables As ADODB.Recordset
Dim Catalog As New ADOX.Catalog
Set Catalog.ActiveConnection = conn
Catalog.Create Request.Form("catalog")
...
String beans = getBeanDefinitionFromUser();
GenericApplicationContext ctx = new GenericApplicationContext();
XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(ctx);
xmlReader.loadBeanDefinitions(new UrlResource(beans));
ctx.refresh();
ACTUATOR 角色的用户才能进行访问。
management.security.enabled=false
endpoints.health.sensitive=false
@Component
public class CustomEndpoint implements Endpoint<List<String>> {
public String getId() {
return "customEndpoint";
}
public boolean isEnabled() {
return true;
}
public boolean isSensitive() {
return false;
}
public List<String> invoke() {
// Custom logic to build the output
...
}
}