ASP.NET MVC Tip #46 – Don’t use Delete Links because they create Security Holes

I created a sample ASP.NET MVC application that I plan to post at the website. While the application was being code reviewed by the ASP.NET MVC Feature team, a surprising objection surfaced.

The application is extremely simple. It contains a view that renders a list of database records. Next to each record, there is an Edit link and a Delete link (see Figure 1). Pretty standard stuff. Or, so I thought…

Figure 1 – A Grid of database records


Here’s the objection. You should not use a link for deleting a record. Using a Delete link opens up a security hole.

The Security Objection

In theory, someone could send an email to you that contains an image. The image could be embedded in the message with the following tag:

<img src=”” _fcksavedurl=”””” />

Notice that the src attribute points at the Delete() method of the Home controller class. Opening the email (and allowing images in your email client) will delete record 23 without warning. This is bad. This is a security hole.

I had come across this security concern in the past, but had not given it much thought. Originally, Microsoft enabled you to invoke ASMX Web Services by performing a HTTP GET request. In .NET Framework 1.1, HTTP GET requests were disabled by default (You can re-enable HTTP GET requests in the Web.config file). This change in behavior was made to prevent these types of HTTP GET security attacks.

The REST Objection

There is one other reason that you should not use a link to perform deletes in an application. REST purists would defend the idea that GET requests should not change the state of your application. In other words, performing a GET operation should be a safe operation that has no side effects.

For example, you don’t want a search engine to delete all of the records in your application while crawling your website. Performing an HTTP GET should have no lasting effect on your application.

The proper HTTP operation to perform, when deleting a record, is an HTTP DELETE. The HTTP protocol supports the following HTTP operations:

· OPTIONS – Returns information about the communication options available (idempotent).

· GET – Returns whatever information is identified by the request (idempotent).

· HEAD – Performs the same operation as GET without returning the message body (idempotent).

· POST – Posts new information or updates existing information (not idempotent).

· PUT – Posts new information or updates existing information (idempotent).

· DELETE – Deletes information (idempotent).

· TRACE – Performs a message loop back (idempotent).

· CONNECT – Used for SSL tunneling.

These operations are defined as part of the HTTP 1.1 standard which you can read about at

Notice that the description of an HTTP POST and HTTP PUT are identical. To understand the difference between a POST and a PUT, you need to understand what it means for an operation to be idempotent. An idempotent operation is an operation that has the same outcome no matter how many times that it is performed.

For example, if you perform a POST operation to create a new database record, then you can create a new database record every time that you perform the POST. A POST operation is not idempotent because it can have a different effect on your application each time the operation is performed.

If, on the other hand, you perform a PUT operation, then the very same database record must be created each time you perform the PUT. A PUT operation is idempotent because performing a PUT operation a thousand times has the same effect as performing the operation one time.

Notice that an HTTP DELETE is also idempotent. Performing the same HTTP DELETE request multiple times should have the very same effect on your application each time the request is made. For example, the request /Home/Delete/23 should delete database record 23, and no other database record, regardless of how many times the request is made.

HTML Supports Only GET and POST

So, the proper thing to do when deleting a database record is to perform an HTTP DELETE operation. Performing an HTTP DELETE does not open a security hole and it does not violate REST principles.

Unfortunately, standard HTML does not support HTTP operations other than GET and POST. A link always performs a GET and a form can perform either a GET or POST. HTML does not support other types of HTTP operations.

According to the HTML 3.1 specification, the HTML FORM tag only supports GET and POST. It does not support other HTTP operations such as DELETE or PUT. See Furthermore, Internet Explorer only supports GET and POST (see

Performing Ajax Deletes

If you are willing to go beyond standard HTML, you can perform HTTP DELETE operations by taking advantage of AJAX. The XmlHttpRequest object supports any of the HTTP operations. Therefore, if you are willing to make your application depend on JavaScript, then you can do everything the right way.

The Home controller in Listing 1 contains an Index() and Delete() method. The Index() method returns all of the movies from the Movies database and the Delete() method deletes a particular movie with a particular Id (this controller uses the Entity Framework).

Listing 1 – ControllersHomeController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using Tip46.Models;

namespace Tip46.Controllers
    public class HomeController : Controller
        private MoviesDBEntities _entities = new MoviesDBEntities();

        public ActionResult Index()
            ViewData.Model = _entities.MovieSet.ToList();
            return View();

        public ActionResult Delete(int id)
            var movieToDelete = (from m in _entities.MovieSet
                                 where m.Id == id
                                 select m).FirstOrDefault();

            return RedirectToAction("Index");


Notice that the Delete() method is decorated with an AcceptVerbs attribute. The Delete() method can only be invoked by an HTTP DELETE operation.

The Index view in Listing 2 displays the movies from the Movies database table within an HTML table. A Delete link is rendered next to each movie record (see Figure 2).

Listing 2 – ViewsHomeIndex.aspx

<%@ Page Title="" Language="C#" MasterPageFile="~/Views/Shared/Site.Master" Inherits="System.Web.Mvc.ViewPage<IEnumerable<Tip46.Models.Movie>>" %>
<asp:Content ID="Content1" ContentPlaceHolderID="MainContent" runat="server">

<script src="../../Scripts/MicrosoftAjax.js" type="text/javascript"></script>

<script type="text/javascript">

    function deleteRecord(recordId)
        // Perform delete
        var action = "/Home/Delete/" + recordId;

        var request = new Sys.Net.WebRequest();

    function deleteCompleted()
        // Reload page




    <% foreach (var item in Model) { %>

                <%-- Ajax Delete --%>
                <a onclick="deleteRecord(<%= item.Id %>)" href="JavaScript:void(0)">Delete</a>

                <%-- GET Delete: Security Hole
                <%= Html.ActionLink("Delete", "Delete", new { id=item.Id })%>--%>
                <%= Html.Encode(item.Id) %>
                <%= Html.Encode(item.Title) %>
                <%= Html.Encode(item.Director) %>
                <%= Html.Encode(item.DateReleased) %>


    <% } %>



Deletes are performed with an Ajax call. The Delete link invokes the JavaScript deleteRecord() function. This function uses the Microsoft ASP.NET AJAX WebRequest object to perform an Ajax call. The WebRequest performs an HTTP DELETE operation.

After the DELETE operation completes, the JavaScript deleteCompleted method is called. This method reloads the current page (a more elegant approach here would be to use the new ASP.NET AJAX Client Template functionality coming with the next version of ASP.NET AJAX. That way, you could just update the grid without reloading the entire page).

Figure 2 – The Index view


But, I Don’t Want to Depend on JavaScript

Many developers do not want their websites to depend on JavaScript. In other words, they want their websites to continue to work with JavaScript turned off. There are somewhat legitimate reasons for this requirement. Not all mobile devices support JavaScript (although most do). And, there are accessibility concerns about JavaScript (although Aria should fix these accessibility problems).

If you want your website to work with JavaScript disabled then you can’t perform an HTTP DELETE when deleting a database record. Instead, you should perform an HTTP POST. An HTTP POST does not expose the same security hole as an HTTP GET operation.

You can use the AcceptVerbs attribute to prevent a controller action from being invoked unless it is invoked with an HTTP POST operation. So, the Delete() action would look like this:

public ActionResult Delete(int id)
    var movieToDelete = (from m in _entities.MovieSet
                         where m.Id == id
                         select m).FirstOrDefault();

    return RedirectToAction("Index");

Unfortunately, the only way to perform an HTTP POST with standard HTML is to use a <form> tag. Furthermore, you must use an <input type=”submit”>, <input type=”image”>, or <input type=”button”> tag to create a button for deleting a record.

There is no such thing as an <input type=”link”> tag. That’s a shame, because links look better than buttons. HTML should not tie appearance to behavior, but it does. You should be able to make a Delete link to delete a record.

The best option here is to use the <input type=”image”> tag. That way, you can make the Delete and Edit links look the same when displaying a grid of database records. Because I did not want to make my sample application depend on JavaScript, this is the approach that I am taking in the sample application.

The non-JavaScript dependent Index view is contained in Listing 3.

Listing 3 – ViewsHomeIndex.aspx (no JavaScript)

<%@ Page Title="" Language="C#" MasterPageFile="~/Views/Shared/Site.Master" Inherits="System.Web.Mvc.ViewPage<IEnumerable<Tip46.Models.Movie>>" %>
<asp:Content ID="Content1" ContentPlaceHolderID="MainContent" runat="server">


    <% foreach (var item in Model) { %>

                <a href='<%= Url.Action("Edit", "Home", new { id = item.Id })%>'><img src="Content/Edit.png" alt="edit" border="0" /></a>
                <% using (Html.BeginForm("Delete", "Home", new { id = item.Id }))
                   { %>
                    <input type="image" src="Content/Delete.png" />
                <% } %>
                <%= Html.Encode(item.Id) %>
                <%= Html.Encode(item.Title) %>
                <%= Html.Encode(item.Director) %>
                <%= Html.Encode(item.DateReleased) %>


    <% } %>


        <%= Html.ActionLink("Create New", "Create") %>


I got the images for the Edit and Delete links from the Visual Studio image library (see Figure 3). You have these set of images on your hard drive at the following location:

C:Program FilesMicrosoft Visual Studio 9.0Common7VS2008ImageLibrary

Figure 3 – Using Images for Edit and Delete


To get the images to align correctly, I added a vertical-align style to the table cells. I used the following style rules:


  border-bottom: solid 1px black;


Don’t use Delete links to delete database records. Potentially, someone could perform a GET request and perform a delete without your consent or control.

The best option is to use JavaScript to perform an HTTP DELETE operation. Using JavaScript enables you to avoid the security hole. Using JavaScript also enables you to respect the semantics of the HTTP protocol.

If you don’t want your application to depend on JavaScript, the second best option is to perform an HTTP POST instead of an HTTP DELETE. Performing a POST operation requires you to use an HTML form. This can be ugly. However, you can improve the appearance of a form button by using an <input type=”image”> tag and adding Cascading Style Sheet styling.


  1. Doug says:

    What about the [Authorize] attribute?

  2. Chad Moran says:

    Hey Stephen, good to see you posting again.

    I agree for the most part but there are clear ways to get around this.

    1) Only accept HTTP Post.
    2) Check referring URL (extend attributes if you have to for DRY)
    3) Anti-forgery tokens already included in ASP.NET MVC.

    This is definitely a good post though. People used to WebForms are going to have to learn how classic web development is handled for security reasons and this is a good example.

    Keep up the good work!

  3. Trevor says:

    I learned allot about HTTP, that I should have known already.


  4. Phil says:


    Thanks a ton for this tip, and the others you’ve posted…they have all been a great help.

    This post got me thinking…if I wanted to get around this security gate I would simply embed a url that calls a page with a JavaScript onload function to POST the delete command.

    I’m just thinking out loud here but it seems there must be a good way to verify the POST is valid.

    …Maybe check the “Refering URL” to make sure it came from the application.

    …or use some sort of security token

    …or maybe even have the user re-validate their credentials if the data is really critical.

    What would you suggest?

  5. Phil says:

    opps…I guess I took too long to reply after reading the post 🙂 (multi-tasking again)

    Seems my thoughts were already spoken.

    Cheers! And keep up the great work!


  6. jdelator says:

    vBulletin uses delete links but after clicking on the delete link, you need to retype your password. If you had a second page where you need to click on something like confirm that you want to delete the items or a page to reauthenticate the password, this attack will get stopped.

  7. @idelator,

    Good point. Maybe the best solution is to use JavaScript HTTP DELETE for uplevel browsers and an extra delete confirm page with an HTTP POST for downlevel browsers.

  8. gunteman says:

    To prevent search robot deletions I’ve used a simple Javascript approach which removes the actual URL from the link :


    Which can be combined with a confirm prompt.

  9. jlharper says:

    I agree with the above posters that discussing this sort of common misuse of GET in the context of a security hole, only to suggest replacing it with another CSRF security hole is not the best choice.

    I also think making this change to please RESTifarians is a bit of a waste, since you have much larger problems to fix first if you want to please them (why are you DELETEing the 23rd /Delete resource? Shouldn’t that remove records of the 23rd deletion?).

    I think the non-safeness of this operation, and why allowing a user to perform something non-safe through GET is bad, is a much stronger argument against it. Remember when GWA came out and accidentally taught the word idempotentic to so much of the web, because of this very sort of delete link? Which leads nicely into why it’s very much in the HTML designer’s intention to not provide a link-style form submission. Because they imagine that the user will learn that blue underlined text is safe, and can be clicked on with no danger, and a button (or a graphical button-like image) is not safe, and should be carefully considered before clicking. Of course too many web app developers don’t follow this idea so very few users have learned an instinct of blue-underline=safe, but it’s still a good idea to follow when designing your own app. Browsers’ tabs are a good pragmatic example of how things get easier if you make sure links are always GETs and GETs are always safe. Because you can easily open links with a middle-click, but not buttons.

    What happens in your AJAX version if I middle-click on a DELETE link? Does it just confusingly do nothing, or does it delete it in the background and leave me with a no-longer valid page state in my first tab (item #23 represented as still existing)? In the example of it being a button, that question is removed, since I can’t middle-click on a delete button.

    Oh, and since you mention idempotency, and since I just saw another post on it today, I thought I’d share it with you. It’s OK for GET Requests to Update the Database is a good reminder not to get too locked into the idea of GET=SELECT and nothing else.

  10. gunteman says:

    Ah, the comments allowed HTML…

    I tried to demonstrate setting the href attribute of a link on the onclick handler.

    .. href=”#” onclick=”this.href=’Delete/23′”

  11. Tri says:

    I agree with jlharper. Your tips actually does not solve anything, just try to replace GET by DELETE or POST command. What happen if I write a small script that automatically uses POST or DELETE because your resource ID is simple to guess?

  12. Farrio says:

    I agree with Doug which is using [Authorize]. Most of the time we will not allow anybody to delete some records without authorization do you think.

  13. Mark says:

    “a” tags shouldn’t be used for deletes.

    Posting Forms should be used for deletes. (If the delete is successful then do a redirect, otherwise return error).

    The javascript ‘delete’ method is just going to far imho, when there is suitable html for this situation.

    You can always use CSS (if you must) to style the submit button so it looks like a link…

  14. hassan says:

    Useful stuff. But regardless of using HTTP Delete with ajax or post back; I think one should always [Authorize] the request. No body wants to delete something in their apps by unauthorized person. i think thats is the best way to address the issue.

  15. Zihotki says:

    Hi all,
    About [Authorise], this will work in this cases:
    a) if you are viewing emails from some email client eg Thunderbird.
    b) if you set in config to keep authorization cookie per browser session (I mean to use not persistent cookies). In this case it will work only when you was visiting your site in previous session and there are no auth cookie.
    In other cases this authorization cookie will be sent if exists. So if you receive a letter with such image link and will read it in browser which has authorization cookie – you’ll delete the item.
    So please use Post or Delete request if you want to make this safe.

    Thanks Stephen, very interesting and useful post! =)
    Best regards.

  16. Hi Stephen,
    IMHO, Use HTTP Post with AntiForgeryToken helper method.

  17. jlharper says:

    I just looked up the AntiForgeryToken helper Shiju suggested, and I want to second his suggestion.

    AntiForgeryToken is precisely the ASP.NET MVC feature intended to combat these CSRF attacks. It’s an implementation of the standard method of sticking a unique token in a cookie and a form and checking that the cookie and form value still match when the form gets submitted, that is, that the form the user has submitted is a form that the web app itself created — something merely checking a user has an authentication cookie won’t help with.

    I think the fact that this post veers off into discussion of proper mapping of HTTP verbs to actions covers up the more important fact that the security hole brought up is of the CSRF class, and that no matter what HTTP verb is used, CSRF must be protected against. In every input-accepting control of your application. It is still probably the most unrecognized, widespread security hole in web applications today, now that knowledge of XSS is starting to spread.

    On the other hand, you do have to note that AntiForgeryToken requires the use of POST, not GET, which leads us back to the discussion of the fact that it’s bad form to use GET for anything dangerous enough that you want to protect from a CSRF attack anyway. Which leads to the reason it’s bad form, which leads to discussion of proper mapping of HTTP verbs to actions. Oh well 🙂

  18. Darren says:

    Have I missed something or isn’t this just a case of making sure the auth’d user has the rights to delete the record?

  19. Jay Adair says:

    Interesting post, thanks. Though I do wonder how often it would even be appropriate to implement it. For instance, in my mind, I can’t think of any delete abilities that would be publically available on a website. They’re always secured and normally tied to an account.

    I’m sure there’s a case I’m not thinking of, and for that I’m sure it’s appropriate, but I can’t think of anywhere in any app I’ve developed where the extra work involved would balance against the benefit.

  20. David says:

    That img tag in the last html code example needs an alt attribute.

  21. Piers Lawson says:

    In my blog I’ve written a whole series on supporting a RESTful web service with MVC and ASP.Net. To help with overloading of POST (to provide support for DELETE and PUT) I created an ActionMethodSelectorAttribute that extended AcceptVerbsAttribute to support overloaded POST. See the Overloading Post entry:…/…erloading-POST.aspx

  22. Cristian Odea says:

    As somebody already mentioned, you didn’t actually resolve anything other than not allowing a search engine to follow the delete links.
    All the security checking should be always in the controller or the layer that handles the rules. Even if you might end up with duplications (like having a second check whether the delete links should be displayed or not in the UI), security is not something to be implemented in html.

    Imho GET / POST / DELETE / PUT or whatever you may use should have absolutely no impact on your application rules.

  23. Mark Kamoski says:

    This…” />

    …is NOT a RESTful URL.

    It has a VERB in it– REST is about NOUNS, remember?

  24. HB says:

    It’s a little lame, but a little CSS styling and you can have a submit button look like a link… :/

  25. Zack says:

    I’m just starting to look at MVC, so I found this discussion really interesting. However, I would point out (I don’t think anyone already posted this) that there is already a good discussion posted at this link.…/#comment-2171
    I found this link directly on the MVC codeplex site here…/View.aspx
    however this article is dated from September and implies that the AntiForgeryToken is in the Futures section of MVC. Is that still the case or has it moved to the Core.

  26. I have to agree w/ some of the other comments here. GET shouldn’t be used for deletes because it has a side-effect. HTML guidelines tell you this. You don’t want to have linkable, favoritable, urls that cause side-effects.

    But it’s still easy to fake a form POST, so the security hole remains. Use the antirequestforgerytoken, the authorize attribute, and other means to protect your application.

    Another thing I’d like to call out is your use of obtrusive javascript. You have quite a following on this blog and you really shouldn’t be advocating code that looks like this:

    ..a href=’javascript:void(0)’ onclick=’doSomething();…

    First, javascript in the HREF attribute is a complete no-no, it should actually point to something (or “#”).

    Second, attaching behavior in the onclick attribute mixes your concerns. You should be attaching this behavior with javascript in the HEAD tag. Something like this (jQuery):

    $(function() {
    $(‘a.some_class_denoting_behavior’).click( function() {
    return false;

    the return false prevents the browser from actually trying to visit the link.

    I recommend reading up on unobtrusive javascript, and if you’re serious, pick up DOM Scripting by Jeremy Keith. It’s a great book. It talks about progressive enhancement, unobtrusive scripting, and complete separation of behavior from content.

    Hope this helps.

  27. nipingupta says:


  28. dc says:

    About being an authorized user, this is still open to the delete attack mentioned.

    Say you are an authorized user and you log into a site in one tab. Now say you open an email in Gmail in another tab. The attack here will work since you are logged into the site.

    It’s worse if you implement a “remember me” feature because then a user can close their browser and the attack will still work.

  29. Thanigainathan says:


    Your article is nice.Thanks for that. I have the following questions.

    1. How can we protect our Aplication from Javascript attacks ?
    2. If we are using JS then we have to expose our links to delete command. Same applies even if we need to get some details from our website.

    Why this is like that ? Do we have alternative ways to achiev this in JS ?


  30. Lee Timmins says:

    I think alot of you are missing the point of the article. While i understand that it is easy to bypass the provided solution by issueing a POST request. The fix addresses the issue that if a user adds an image (src pointing to a delete action) to an email and the person receiving that email has already been authorized then the delete would still take place. I guess the ideal solution would be a combination or POST and authorisation although if you really wanted to achieve this with GET then i would implement some form of confirmation.

  31. jlharper says:

    I disagree Lee; that is the point of the article, but we’re pointing out it’s the wrong point.

    While this fix (switch from GET to POST) addresses the one, specific problem of a forged GET request (in the example, an image), it still leaves it open to a forged POST request, which is not any harder to forge.

    It is not difficult to get a user to click a link, and that’s all that’s necessary to forge a POST request. You also just clicked the submit button on this comment form — and probably clicked at least 10 >input type=”button”<s today on web pages without thinking about it, and without viewing the source to see exactly which URL the form was going to submit to. If one of those buttons told your browser / email client to send a POST request to your app, you would be unaware of what was being sent, where, until the delete URL of your app has redirected you to the index page of your app, post-delete.

    And then consider the possibility of a page with both a forged form and some onload javascript which automatically submits the form the second you visit the page. All that would be required then to delete your database would be a single click on a link, pointing at some outside web site, and next thing you know you’re staring at your web app, post-delete.

    Authentication does not solve this problem. If you are authenticated with your app, your browser is authenticated with your app, and the fake form is going to be authenticated with your app when it tells it that you have just asked for the deletion of the database or transfer of money. Aggressive timeouts and reminders to always logout may catch some CSRF attacks at a login screen, but do nothing to when your app is open in the background in another window or another tab, or a user just closed the tab but is still within the timeout period.

    Yes, your email client may have a different cookie jar from your browser and so not be authenticated with your app, but protection only for an email client / second browser is not enough of a solution, when something called the world wide web exists and your users are going to be visiting it with the same browser they use for your app.

    And if you add a confirmation step, what stops the attacker from just pointing at the URL that indicates confirmation?

    CSRF is a security hole in your apps right now, if you aren’t taking steps to prevent it on every single form and in every single input-accepting or action-taking URL in your app. The easiest, most common, defense is a random per-user or per-formview token, stuck in both a cookie and as an input to a form, and a check on the form’s submission that the token was submitted along with the form to make sure the form was generated by your app (since only your app will have permission to read or write the cookie). ASP.NET MVC calls its implementation of this pattern AntiForgeryToken.

  32. jlharper says:

    LOL, I never can keep the names of less-than and greater-than straight! I meant <input type=”button”> (and won’t it be embarrassing if this comes out inverted also!)

  33. keith says:

    Many thanks for your extensive comments on this issue, they were very informative.

  34. Champs says:

    Of course the confirmation page could be where a POST is required.

    Better still, if your models aren’t too deeply entrenched, you could skip the actual record deletion and use a binary field, i.e. never use a warning when you mean undo.

  35. JJ Rock says:

    My initial thought is that this post creates more problems than it solves.

    From what I remember, HTTP DELETE and PUT commands existed to support file resources on a remote server. Similiar to commands used by the FTP protocol. I have never seen any web application utilize either of these two methods for any reason.

    Additionally, in default IIS installations the verbs accepted for most filetypes do not include DELETE and PUT. The most common (as I have observed in IIS on XP) are GET, HEAD, POST, and DEBUG. I believe there is a great reason for this: the other methods were never intended for use with the way the web works today.

  36. Venu says:


    How to Configure MVC Beta + IIS 7.0 + HTTPS with PUT and DELETE verbs

  37. jlharper says:

    Looks like AntiForgeryToken is now part of ASP.NET MVC (as of RC1).

  38. Franck Quintana says:

    A can be an alternative too so it can be styled with CSS too.

    Take a look at this article for more information…/rediscovering-the-button-e…

  39. Franck Quintana says:

    button type=”submit”

    seems I found a bug in the parser 🙂

  40. Franck Quintana says:

    Here is the link to the article…/rediscovering-the-button-e…

  41. I don’t want application to depend on JavaScript. The best option is to perform an HTTP POST instead of an HTTP DELETE. Performing a POST need to use an HTML form. This can be ugly.

  42. mike says:

    intrinsically GET requests don’t create security holes. privileged operations require authorization. this is not just the delete operation, there are many operations that require the client to go through an AA phase. just as a registered user of an online trading site cannot view records of another user (generally a get operation BTW) there is no reason to assume that delete would no provide similar restrictions on the application level.

  43. Nice Post! Thanks for the advice.

  44. Developers can easily leverage the Model-View-Controller pattern in ASP.NET applications. Pulling logic away from the UI and the views has been difficult for a long time. The Model-View-Presenter pattern helps a little bit, but the fact that the view has to delegate to the presenter makes the UI pattern difficult to work with.

  45. Great Information, this will be very helpful to me.

  46. pune net says:

    I admit, I have not been on this webpage in a long time… however it was another joy to see It is such an important topic and ignored by so many, even professionals.

  47. Awek Melayu says:

    THanks for the great article. it’s been a while since i visited your blog and it’s great that someone wrote about it finally.

  48. So let me get this straight? If I have a link that says delete and by clicking on it then it should delete the database info I am trying to delete, and yet that causes a security risk, what is the best 2.0 way to resolve this problem. Now, the problem is only a problem when a site is public, right?

  49. This was very informative and detailed. Thanks a lot for the info!!

  50. will says:

    thanks for script, very useful

  51. I am on my second pair!
    Sometimes I wear them just for the peace and quiet – no IPod, no movie, no screaming children, no seatmate yammering. What’s the price of peace and quiet? Priceless!online associate degrees | business school

  52. james says:

    Beats by Dr. Dre. They are a bit expensive, but totally worth it. Online Education degree |
    fire school

  53. girchar says:

    This is good one to provide the better learning of ASP.NET. Transparency and access to information is should be a golden standard we aim for here in the UK. Let’s all hope Tim and Digital Engagement go some way of getting there.Exploratory Essay

  54. asus laptops says:

    Can u compare jsp and over security issues, fastness, cost effective? Which is best to avoid hacking?

  55. tutu says:

    サイト売買 is wonderful.
    私書箱 is wonderful.
    屋形船 is wonderful.
    店舗デザイン is wonderful.
    整体学校 is wonderful.
    お見合いパーティー is wonderful.
    債務整理 is wonderful.
    演劇 is wonderful.
    新宿 整体 is wonderful.
    会社設立 is wonderful.
    マカ is wonderful.
    格安航空券 国内 is wonderful.
    ブライダルエステ is wonderful.
    募金 is wonderful.
    オーディション is wonderful.
    広島 不動産 is wonderful.
    バイク便 is wonderful.
    ボイストレーニング is wonderful.
    過払い is wonderful.
    バラ is wonderful.
    部分やせ is wonderful.
    先物取引 is wonderful.
    洗面化粧台 is wonderful.
    税理士 東京 is wonderful.
    婚活 is wonderful.
    ウェディングドレス is wonderful.
    結婚式 青山 is wonderful.
    薬剤師 求人 is wonderful.
    トイレつまり is wonderful.
    外国商標 is wonderful.
    電話代行 東京 is wonderful.
    ハーレー is wonderful.
    賃貸オフィス is wonderful.
    相続 is wonderful.
    ビル管理 is wonderful.
    債務整理 東京 is wonderful.
    助成金 横浜 is wonderful.
    不眠症 治療 is wonderful.
    ディズニーランド is wonderful.
    我孫子市 一戸建て is wonderful.
    浦和 不動産 is wonderful.
    業務用エアコン is wonderful.
    照明 インテリア is wonderful.
    生い立ちビデオ is wonderful.
    相続税対策 is wonderful.
    歯並び is wonderful.
    ゴルフ会員権 is wonderful.
    上尾 不動産 is wonderful.
    幼児 習い事 is wonderful.
    中古医療機器 買取

  56. There is one other reason that you should not use a link to perform deletes in an application. REST purists would defend the idea that GET requests should not change the state of your application. In other words, performing a GET operation should be a safe operation that has no side effects.
    .thanks for sharing your views..
    Free online games. .

  57. 2010 fusion says:

    I have always had problems with ajax on my work out plans blog.

  58. victor says:

    f you are willing to go beyond standard HTML, you can perform HTTP DELETE operations by taking advantage of AJAX but i have a problem with Ajex.

    Wedding Dresses
    Wedding Flowers

  59. carcarchen says:

    Yes, better don’t delete the links manually. cheap car insurance. I prefer to make my blog no follow or break the links so that they no longer work.

  60. the coding is great and can any one one suggest ho to protect the scripts?

  61. I just heard about this. Never knew before, but I guess there are many others who also don’t realize the holes. Thank you.. I hope my bankruptcy discharge papers website hasn’t deleted much.

  62. james lee says:

    this some great information. You do not want security holes.
    wedding tips
    free wedding information
    inexpensive wedding ideas

  63. Andreas says:

    Very interesting article.
    Many thanks for the share of the information.


  64. pharmacy says:

    Nice article.
    The code works fine and is a good starting point for me making a custom module.
    Thanks for the module…

  65. John Franklin says:

    Cleared up quite a few things and learned something along the way. Thanks.

    weight loss pills for women Appetite suppressant pills Hide my IP free trial

  66. toko obat says:

    Such an excellent post, thank you for sharing

  67. online poker says:

    Why does my ASP.NET application work on my local machine but not when I upload it to the server?

  68. Thanks for explaining this pretty neat application, definitely helps with the screenshots to understand the code, thanks!

  69. Lovelinks says:

    I agree with the others regarding using GET for deletes due to the side effects, I have had a few problems with this in the past. Great article though and interesting stuff.

  70. Thanks for explaining this, the code works fine for me, I’m going to be starting a custom module this week.

  71. matt says:

    Yes, better don’t delete the links manually.
    Essay| Essays| Essay Writing| Essay Help| Custom Essay|

  72. jeff says:

    Developers can easily leverage the Model-View-Controller pattern in ASP.NET
    Buy Essay| Online Essay| Essay Writing Service| Essay Service| Essay Topics|

  73. It’s lucky to know this, if it is really true. Companies tend not to realize when they create security holes from day-to-day operation. I work for a reputable Concrete Sealer company and even sometimes it is hard to keep the optimal security standards.

  74. tadalafil says:

    Nice article.The code works fine and is a good starting point for me making a custom module.Thanks for the module…

  75. XRF says:

    Can I download DLC for guitar hero world tour wii without an internet connection ,via the computer?

  76. Makoto says:

    I would have to say that using the DELETE verb might be more of a headache in bigger corporations, since by default, IIS only allows the following verbs : GET, HEAD, POST, DEBUG . In the companies I’ve worked at, the developers don’t control the servers, so the developers would have to notify the IT team to allow the DELETE verb, and then if you have a server farm, this would have to be added to all the servers. Not to mention, if you use URLScan, by default it also doesn’t allow the DELETE verb.

    I’d say JavaScript should be used for Deletes, since it’s a good idea to have a confirmation dialog asking if you’re really sure you want to delete, and then which would create an HTTP POST.

  77. There are specific techniques and exercises you can employ to help prevent premature ejaculation. Fortunately , medical science in addition has developed a bewildering array of early ejaculation solutions. We’ve analyzed the formulas, polled our audience, totaled the results ( and read virtually 8000 emails ) to discover the top-recommended early ejaculation products. All so you can get help.Men who have continuing early ejaculation troubles don’t want to do exercises, use funny positions or create excuses. They need a cure and they need it immediately.A early ejaculation cure has to work fast and it has got to be 100 percent trustworthy. Not just that, but it has got to be something that doesn’t ruin the mood.

    control premature ejaculation

    ejaculation trainer

    ejaculation master


    premature ejaculation treatment