php注入教程

㈠ 伪静态php网站该如何注入渗透，求大神告知，解答下

thinkphp漏洞还是蛮多的~ 首先你要知道thinkphp的运行方法而不是盲目的去注入

比如Home/Login/index.html

Home/Login/index/ID/1

㈡ php防sql注入的代码

一、 注入式攻击的类型
可能存在许多不同类型的攻击动机，但是乍看上去，似乎存在更多的类型。这是非常真实的-如果恶意用户发现了一个能够执行多个查询的办法的话。本文后面，我们会对此作详细讨论。
如
果你的脚本正在执行一个SELECT指令，那么，攻击者可以强迫显示一个表格中的每一行记录-通过把一个例如"1=1"这样的条件注入到WHERE子句中，如下所示(其中，注入部分以粗体显示)：
SELECT * FROM wines WHERE variety = ’lagrein’ OR 1=1;’

正如我们在前面所讨论的，这本身可能是很有用的信息，因为它揭示了该表格的一般结构(这是一条普通的记录所不能实现的)，以及潜在地显示包含机密信息的记录。
一条更新指令潜在地具有更直接的威胁。通过把其它属性放到SET子句中，一名攻击者可以修改当前被更新的记录中的任何字段，例如下面的例子（其中，注入部分以粗体显示）：
UPDATE wines SET type=’red’，’vintage’=’9999’ WHERE variety = ’lagrein’

通过把一个例如1=1这样的恒真条件添加到一条更新指令的WHERE子句中，这种修改范围可以扩展到每一条记录，例如下面的例子（其中，注入部分以粗体显示）：
UPDATE wines SET type=’red’，’vintage’=’9999 WHERE variety = ’lagrein’ OR 1=1;’

最危险的指令可能是DELETE-这是不难想象的。其注入技术与我们已经看到的相同-通过修改WHERE子句来扩展受影响的记录的范围，例如下面的例子（其中，注入部分以粗体显示）：
DELETE FROM wines WHERE variety = ’lagrein’ OR 1=1;’

二、 多个查询注入
多个查询注入将会加剧一个攻击者可能引起的潜在的损坏-通过允许多条破坏性指令包括在一个查询中。在使用MySQL数据库时， 攻击者通过把一个出乎意料之外的终止符插入到查询中即可很容易实现这一点-此时一个注入的引号(单引号或双引号)标记期望变量的结尾；然后使用一个分号终 止该指令。现在，一个另外的攻击指令可能被添加到现在终止的原始指令的结尾。最终的破坏性查询可能看起来如下所示：
SELECT * FROM wines WHERE variety = ’lagrein’;
GRANT ALL ON *.* TO ’BadGuy@%’ IDENTIFIED BY ’gotcha’;’

这个注入将创建一个新的用户BadGuy并赋予其网络特权（在所有的表格上具有所有的特权）；其中，还有一个"不祥"的口令被加入到这个简单的SELECT语句中。如果你遵循我们在以前文章中的建议－严格限制该过程用户的特权，那么，这应该无法工作，因为web服务器守护程序不再拥有你撤回的GRANT特权。但是从理论上讲，这样的一个攻击可能给予BadGuy自由权力来实现他对你的数据库的任何操作。
至 于这样的一个多查询是否会被MySQL服务器处理，结论并不唯一。这其中的一些原因可能是由于不同版本的MySQL所致，但是大多数情况却是由于多查询存 在的方式所致。MySQL的监视程序完全允许这样的一个查询。常用的MySQL GUI-phpMyAdmin，在最终查询之前会复制出以前所有的内容，并且仅仅这样做。
但是，大多数的在一个注入上下文中的多查询都是由PHP的mysql 扩展负责管理的。幸好，默认情况下，它是不允许在一个查询中执行多个指令的；试图执行两个指令(例如上面所示的注入)将会简单地导致失败-不设置任何错 误，并且没有生成任何输出信息。在这种情况下，尽管PHP也只是"规规矩矩"地实现其缺省行为，但是确实能够保护你免于大多数简单的注入式攻击。
PHP5中的新的mysqli扩展(参考http://php.net/mysqli)，就象mysql一样，内在地也不支持多个查询，不过却提供了一个mysqli_multi_query()函数以支持你实现多查询-如果你确实想这样做的话。
然而，对于SQLite-与PHP5绑定到一起的可嵌入的SQL数据库引擎(参考http://sqlite.org/和http://php.net/sqlite) 情况更为可怕，由于其易于使用而吸引了大量用户的关注。在有些情况下，SQLite缺省地允许这样的多指令查询，因为该数据库可以优化批查询，特别是非常 有效的批INSERT语句处理。然而，如果查询的结果为你的脚本所使用的话（例如在使用一个SELECT语句检索记录的情况下）， sqlite_query()函数却不会允许执行多个查询。三、 INVISION Power BOARD SQL注入脆弱性
Invision Power Board是一个着名的论坛系统。2005年五月6号，在登录代码中发现了一处SQL注入脆弱性。其发现
者为GulfTech Security Research的James Bercegay。
这个登录查询如下所示：
$DB->query("SELECT * FROM ibf_members WHERE id=$mid AND password=’$pid’");

其中，成员ID变量$mid和口令ID变量$pid被使用下面两行代码从my_cookie()函数中检索出：
$mid = intval($std->my_getcookie(’member_id’));
$pid = $std->my_getcookie(’pass_hash’);

在此，my_cookie()函数使用下列语句从cookie中检索要求的变量：
return urldecode($_COOKIE[$ibforums->vars[’cookie_id’].$name]);

【注意】从该cookie返回的值根本没有被处理。尽管$mid在使用于查询之前被强制转换成一个整数，但是$pid却保持不变。因此，它很容易遭受我们前面所讨论的注入类型的攻击。
因此，通过以如下方式修改my_cookie()函数，这种脆弱性就会暴露出来：
if ( ! in_array( $name，array(’topicsread’， ’forum_read’，’collapseprefs’) ) )
{
return $this->
clean_value(urldecode($_COOKIE[$ibforums->vars[’cookie_id’].$name]));
else
{
return urldecode($_COOKIE[$ibforums->vars[’cookie_id’].$name]);
}

经过这样的改正之后，其中的关键变量在"通过"全局clean_value()函数后被返回，而其它变量却未进行检查。
现 在，既然我们大致了解了什么是SQL注入，它的注入原理以及这种注入的脆弱程度，那么接下来，让我们探讨如何有效地预防它。幸好，PHP为我们提供了丰富 的资源，因此我们有充分的信心预言，一个经仔细地彻底地使用我们所推荐的技术构建的应用程序将会从你的脚本中根本上消除任何可能性的SQL注入-通过在它 可能造成任何损坏之前"清理"你的用户的数据来实现。
四、 界定你的查询中的每一个值
我们推荐，你确保界定了你的查询中的每一个值。字符串值首当其冲，以及那些你通常期望应该使用"单"(而不是"双")引号的内容。一方面，如果你使用双引 号来允许PHP在字符串内的变量替代，这样可以使得输入查询更为容易些；另一方面，这(无可否认，只是极少量地)也会减少以后PHP代码的分析工作。
下面，让我们使用我们一开始使用的那个非注入式查询来说明这个问题：
SELECT * FROM wines WHERE variety = ’lagrein’

或以PHP语句表达为：
$query = "SELECT * FROM wines WHERE variety = ’$variety’";

从技术上讲，引号对于数字值来说是不需要使用的。但是，如果你并不介意用引号把例如葡萄酒这样的一个域相应的一个值括起来并且如果你的用户把一个空值输入到你的表单中的话，那么，你会看到一个类似下面的查询：
SELECT * FROM wines WHERE vintage =

当然，这个查询从语法上讲是无效的；但是，下面的语法却是有效的：
SELECT * FROM wines WHERE vintage = ’’

第二个查询将(大概)不会返回任何果，但是至少它不会返回一个错误消息。
五、 检查用户提交的值的类型
从前面的讨论中我们看到，迄今为止，SQL注入的主要来源往往出在一个意料之外的表单入口上。然而，当你经由一个表单向用户提供机会提交某些值时，你应该有相当的优势来确
定 你想取得什么样的输入内容-这可以使得我们比较容易地检查用户入口的有效性。在以前的文章中，我们已经讨论过这样的校验问题；所以，在此，我们仅简单地总 结当时我们讨论的要点。如果你正在期望一个数字，那么你可以使用下面这些技术之一来确保你得到的真正是一个数字类型：
�6�1 使用is_int()函数(或is_integer()或is_long())。
�6�1 使用gettype()函数。
�6�1 使用intval()函数。
�6�1 使用settype()函数。
为 了检查用户输入内容的长度，你可以使用strlen()函数。为了检查一个期望的时间或日期是否有效，你可以使用strtotime()函数。它几乎一定 能够确保一位用户的入口中没有包含分号字符(除非标点符号可以被合法地包括在内)。你可以借助于strpos()函数容易地实现这一点，如下所示：if( strpos( $variety， ’;’ ) ) exit ( "$variety is an invalid value for variety!" );

正如我们在前面所提到的，只要你仔细分析你的用户输入期望，那么，你应该能够很容易地检查出其中存在的许多问题。
六、 从你的查询中滤去每一个可疑字符
尽管在以前的文章中，我们已经讨论过如何过滤掉危险字符的问题；但是在此，还是让我们再次简单地强调并归纳一下这个问题：
�6�1 不要使用magic_quotes_gpc指令或它的"幕后搭挡"-addslashes()函数，此函数在应用程序开发中是被限制使用的，并且此函数还要求使用额外的步骤-使用stripslashes()函数。
�6�1 相比之下，mysql_real_escape_string()函数更为常用，但是也有它自己的缺点。

㈢ 谁有PHP的基础教程

php教程(90.24G)网络网盘免费资源在线学习

链接: https://pan..com/s/1jK3nM2UxdXwTml7bL10POg

php教程(90.24G)

29.-react前后端分离(电影项目) 28.小程序(laravel教育系统) 27.公众号开发 26.laravel框架 25.-sphinx+页面静态化 24.网站优化 23.MongoDB 22.Redis 21.Memcache缓存设计 20 Nginx服务器集群 19.ThinkPHP5品优购商城 18 Restful 17.ThinkPHP5框架 16.VUE项目

㈣ PHP安装以及教程

tomcat ?
据说tomcat配PHP效果不是很好..还是换apache吧....
apache吗..反正几乎是一路next就可以装好了..不过你如果装了IIS..就要注意端口问题..可能会有冲突..mysql也是.一路next,php吗..我是这么样的..
1.下载下来的php包解压..文件夹最好直接命名成php.
2.将php.ini-recommended改名为php.ini(这个是php的配置文件).放到c:\windows下(不放这里好像会有问题)
3.php.ini设置:extension_dir = "c:\php\ext"设置成你的ext文件夹的目录,去掉extension=php_mysql.dll前面的分号(加载mysql扩展).需要什么扩展可以根据需要修改.
4.apache的设置:apache安装目录下的conf文件夹下.找到httpd.conf,DocumentRoot "d:/wwwroot"
这里是你的网站的目录,
在最后添加
LoadMole php5_mole "c:/php/php5apache2_2.dll"(加载php模块)
AddType application/x-httpd-php .php (可解析的php扩展名)
AddType application/x-httpd-php-source .phps (这个不记得了.反正肯定要的)

如果发现权限不够.找到这里
<Directory />
Options FollowSymLinks
AllowOverride None
Order deny,allow
allow from all
options indexes
</Directory>
原来是deny from all改成allow from all.
最好打开apache的目录显示.
Options Indexes FollowSymLinks去掉前面的#,如果还不可以.就在上面的allow from all下面加上options indexes就OK了.
这是win下面的apache+php的配置..
mysql安装比较简单..我就不说了...
PHP的电子教程网上非常多..在这里也不可能给你贴出来吧..
还有关于框架..框架网上的教程也很多..网络一下吧..
着名的框架有zend Framework,cakephp,国产的fleaphp,thinkphp等等...

㈤ 在确定一个网站的admin.php文件存在SQL注入漏洞，可以被注入之后，应该如何进行注入操作

SQL 语句查询他的数据库管理员的帐号密码，然后通过SQL更改他服务器的系统设置 给自己开一个系统管理员的权限 之后就可以远程登入他的服务器了 之后想干什么 那就看你心情了 嘎嘎

㈥ php注入函数到底能不能注入

php 5.00 版本以上自带防注入功能。
所谓的SQL（结构化查询语言）注入，简单来说就是利用SQL语句在外部对SQL数据库进行查询，更新等动作。

㈦ [php]这个注入函数怎么用，放在哪里

应该是调用，在页面传值进来时进行调用；

如：
$id = unsqlin("$_post['传入框的名字']")；

要是防SQL注入，其实可以使用mysql_escape_string（）这个函数。方法和上面的一样。

㈧ php依赖注入是在构造函数中注入吗

PHP 依赖注入
tags: dependency injection,php
by Ryan on January 8, 2009
Dependency injection is the answer to more maintainable, testable, molar code.
依赖注入是对于要求更易维护，更易测试，更加模块化的代码的答案。
Every project has dependencies and the more complex the project is the more dependencies it will most likely have. The most common dependency in today’s web application is the database and chances are if it goes down the app will all together stop working. That is because the code is dependent on the database server… and that is perfectly fine. Not using a database server because it could one day crash is a bit ridiculous. Even though the dependency has its flaws, it still makes life for the code, and thus the developer, a lot easier.
每个项目都有依赖（外界提供的输入）, 项目越复杂，越需要更多的依赖。在现今的网络应用程序中，最常见的依赖是数据库，其风险在于，一旦数据库暂停运行，那么整个程序也因此而停止运行。这是因为代码依赖数据库服务器。。。这已足够。因为数据库服务器有时会崩溃而弃用它是荒谬的。尽管依赖有其自身的瑕疵，它仍然使代码，因而也使程序开发人员的生活更容易些。
The problem with most dependencies its the way that code handles and interacts with them, meaning, the problem is the code and not the dependency. If you are not using dependency injection, chances are your code looks something like this:
对于大多依赖而言，问题在于代码如何处理它们及与它们交往。也就是说，问题是代码本身而非依赖。如果你没有使用依赖注入，有机会遇到下列代码：
class Book {
publicfunction __construct(){
$registry = RegistrySingleton::getInstance();
$this->_databaseConnection=$registry->databaseConnection;
// or
global$databaseConnection;
$this->_databaseConnection=$databaseConnection;
}
}
The book object now is given full access to the database once it is constructed. That is good, the book needs to be able to talk to the database and pull data. The problem lies in the way the book gained its access. In order for the book to be able to talk to the database the code must have an outside variable named $databaseConnection, or worse, it must have a singleton pattern class (registry) object containing a record for a databaseConnection. If these don’t exist the book fails, making this code is far from molar.
现在对象book一旦建立，就已经完全连到数据库。这没什么不好，book需要跟数据库交谈并取得数据。问题在于book取得其接入的方法。要使book能够与数据库交谈，代码必须有一个外来的变量$databaseConnect, 更糟糕的是，它必须有个singleton类型类(registry)的对象，其包含一个databaseConnection的记录。如果这些不存在的话，book会无法运行，这就使得这些代码远远不够模块化。
This raises the question, how exactly does the book get access to the database? This is where inversion of control comes in.
这就提出一个问题，到底book如何接入数据库？这就是IoC出现的原因了。
In Hollywood a struggling actor does not call up Martin Scorsese and ask for a role in his next film. No, the opposite happens. Martin Scorsese calls up the broke actor and asks him to play the main character in his next movie. Objects are struggling actors, they do not get to pick the roles they play, the director needs to tell them what to do. Objects do not get to pick the outside systems they interact with, instead, the outside systems are given to the objects. Remember this as Inversion of Control: The Hollywood Way.
在好莱坞，一个濒临绝境的演员不会打电话给Martin Scoresese要求在他的下个影片中扮演一个角色。绝不会这样，实际正相反。Martin Scorese 会打电话给这个困顿的演员并邀请他在下一部影片中扮演重要的角色。对象是挣扎中的演员，他们不会去捡自己所扮演的角色，导演需要告诉他们去做什么。对象不会到它所接触的外界挑选系统，相反，外界系统会被赋予对象。记住这就是IoC( Inversion of Control):好莱坞的做法。
This is how a developer tells his objects how to interact with outside dependencies:
如下是开发人员告诉他的对象如何与外界的依赖打交道：
class Book {

publicfunction __construct(){}

publicfunction setDatabaseConnection($databaseConnection){
$this->_databaseConnection=$databaseConnection;
}

}
$book=new Book();
$book->setDatabase($databaseConnection);
This code allows for the book class to be used in any web app. The Book is no longer dependent on anything other than the developer supplying a database shortly after object creation.这代码允许这个book类能在任何的网页程序中使用。此book不再依赖任何事项，除了程序开发者要在对象创建后立即要提供一个数据库。
This is, at its finest, dependency injection. There are two common practices of injecting dependencies. The first being constructor injection and the second being setter injection. Constructor injection involves passing all of the dependencies as arguments when creating a new object. The code would look something like this:
这就是最佳方法—依赖注入。有两种常用的依赖注入的方式。一种是 constructor (注：构造函数。这种译法似乎并不恰当，类中此方法更多是用来对某些属性进行初始化)注入，一种是setter 注入。Constructor注入涉及到将所有依赖作为参数，传递给新创建的对象。看起来像这样：
$book=new Book($databaseConnection,$configFile);
The more dependencies an object has, the messier this construction becomes. There are other reasons why this is a bad approach, involving ideas around code reusability and constructors doing work.
对象的依赖越多，construction就会变得越杂乱。这里还有其他的原因为什么这是一个坏方法，其涉及到包括代码重用和constructors要做的工作。
This leaves us with other method of dependency injection, called setting injection, which involves creating a public method inside the object for the dependencies that need injection.
这就给我们留下其他的方法进行依赖注入，称为设置注入，包含在需要注入依赖的对象里创建一个公共方法：
$book=new Book();
$book->setDatabase($databaseConnection);
$book->setConfigFile($configFile);
This is easy to follow, but it leads writing more and more code for your application. When a book object is created three lines of code are required. If we have to inject another dependency, a 4th line of code is now needed. This gets messy quickly.
这很容易实现，但是它会导致为您的程序写大量代码。当创建一个book对象时，需要三行代码。如果我们必须注入另外的依赖时，必须增加第四行代码。这很快变得一团糟。
The answer to this problem is a factory, which is class that is designed to create and then inject all the dependencies needed for an object. Here is an example:
此问题的对策是一个工厂factory，它是一个类，用来创建然后注入一个对象的所有依赖。举例如下：
class Factory {

public static $_database;

public static function makeBook(){
$book=new Book();
$book->setDatabase(self::$_database);
// more injection...（更多注入）
return$book;
}
}
And then:
然后：
$book= Factory::makeBook();
All dependencies should be registered into the factory object ring run time. This object is now the gateway that all dependencies must pass through before they can interact with any classes. In other words, this is the dependency container.
所有的依赖在运行期间都应在此factory对象中注册。它现在是大门，在依赖可以与任何对象打交道前，都必经此门。
The reason makeBook is a public static function is for ease of use and global access. When I started this article off I made a reference to the singleton pattern and global access being a poor choices of code. They are… for the most part. It is bad design when they control access, but it is perfectly ok when they control creation. The makeBook function is only a shortcut for creation. There is no dependency what-so-ever between the book class and the factory class. The factory class exists so we can contain our dependencies in one location and automatically inject those dependencies with one line of code creation.
makeBook作为一个静态方法的原因是易用并且可以在全局得到。在本文开头，我提出使用singleton类型和全局变量对代码而言是一个糟糕的选择。多数情形下，确实如此！当他们控制接入时，是一个差设计。但是在他们控制创建时，是一个不错的选择。makeBook方法仅仅是创建的一个捷径。在book类和factory类之间，没有任何依赖。由于factory类的存在，我们的依赖可以存放在一个地点，并且用一行创建代码就可自动注入这些依赖。
The factory or container class removes all of the extra work of dependency injection.
此处的factory或者容器类移走了依赖注入的所有额外工作。
Before injection:
以前的注入：
$book=new Book();
And now:
目前的方法：
$book= Factory::makeBook();
Hardly any extra work, but tons of extra benefits.
几乎没有任何的额外工作，但是有大量益处。
When test code is run, specifically unit tests, the goal is to see if a method of a class is working correctly. Since the book class requires database access to read the book data it adds a whole layer of complexity. The test has to acquire a database connection, pull data, and test it. All of a sudden the test is no longer testing a single method in the book class, it is now also testing database. If the database is offline, the test would fail. This is FAR from the goal a unit test.当运行测试代码时，尤其是单元测试，其目标是检查类中的方法是否正确地工作。由于book类要求接入数据库并且读取图书数据，它增加了一层复杂度。此测试不得不进行数据库连接，取得数据，然后测试它。瞬间，测试不再是测试book类中的单个方法，它目前同时也测试数据库。如果数据库离线，测试就会失败。这已经远离了单元测试的目的。
A way of dealing with this is just using a different database dependency for the unit tests. When the test suite starts up a mmy database is injected into the book. The mmy database will always have the data the developer expects it to have. If a live database was used in a unit test the data could potentially change causing tests to unnecessarily fail. There is no need for a unit test to be refactored when a record in a database changes.
解决上述问题的方法是用不同的数据库依赖来作单元测试。当测试套件开始时，虚拟的数据库被注入book.虚拟数据库将永远拥有开发人员所期待的数据。如果使用一个真实数据库，数据的潜在变化会导致测试不必要的失败。当数据库的记录改变了，不需因此重新进行单元测试。
The code is more molar because it can dropped into any other web application. Create the book object and inject a database connection with $book->setDatabase(). It does not matter if the database is in Registery::Database, $database, or $someRandomDatabaseVarible. As long as there is a database connection the book will work inside any system.
此代码现在更加模块化，因为它可以被放到任何其他的网页程序。创建book对象并且用$book->setDatabase()注入数据库连接。此时，数据库在 Registery::Database, $database,或者$someRandomDatabaseVarible都无关大局。只要有一个数据库连接，book就可以在任何系统内工作。
The code is more maintainable because each object given exactly what it needs. If separate database connections are required between different instances of the same class then there no extra code needed inside the class what-so-ever. Give book1 access to database1 and book2 access to database2.
代码更加易维护，因为每个对象都被赋予了它的所需。如果同一类的实例需要不同的数据库连接，在类内部一点儿也不需要额外的代码。例如book1连接到数据库1，book2连接到数据库2
Factory::$_database=$ourDatabaseVarForDB1;

$book1= Factory::makeBook();
$book2= Factory::makeBook();
$book2->setDatabase($database2);
Dependency injection really is the answer to more maintainable, testable, molar code.
依赖注入真的是更易维护，更易测试和更加模块化的答案。

㈨ php + mysql 检测到注入漏洞，如何注入脚本删除数据

同一句语句里是不允许出现你这种格式的
如果你是有两条语句需要依次运行，那你可以用分号隔离。
比如：
insert into article_tmp select * from article;
delete from article;
不过你这两句语句有严重的逻辑性问题
delete from article;这句已经把article表里的数据都删了。你紧接着要select * from article，那你返回的肯定是空值，都被你前一句删了。