Orkut New feature -schedule events from your Orkut Profile

though I did not find this feature much useful, still I gave it a try. Immediately after hitting the ‘events’ button on the left sidebar of my homepage, I got a form to fill and I did so by entering one of my friend’s birth day and also invited some of my friends too, to attend the event. Guess all the invitees have got an invitation and have an option either to accept, reject or choose the option ‘may be attending’ for the invitation sent to them.



Well many things done and said, but it matter not how much features Orkut introduces, but what matters is how useful are those feature..? You too give it a try and let us know, personally how useful did you find this feature. 

Read More

How To Turn Youtube Flv Videos Into mp3

This is simple and most of you might already know it..but i thought i'd post it anyway.



I tought of this my self while i was converting 3gp (mobile phone) videos into .avi



First what you have to do is download a youtube video using a grabber or a grabing site (like tubeg





(save it as .flv (you all know that:P ) )



Then you can convert it to .avi or mpg or w/e you want simply by using this site



(thedoors gave me this long time ago )



NOw when you browse and put the file it will give you a list of extention that you can cnvert it too..no mp3 is in there..unfotrunately you can only convert it to another video form....so you should voncert it to 3gp



Then you will browse the 3gp file again and you will see that there are 2 3gp types..one is for video and one is for music..choose the sound type (this way your file will be recongized are pure sound and no video in it) then you can choose convert to :mp3..and all done



that's it..pretty easy and pretty usefull since here are so many cool live conserts and music videos that i can't find on mp3

Read More

How To Skin Your Gui's In C\c++

Hi all, in this tutorial I will be teaching you the basics of skinning your Win32 GUIs(Graphical-User-Interface’s) using C\C++. I hope you enjoy and learn something from this tutorial.



Questions and answers:

Q. What do you mean by skinning?

If you have ever used Windows media player or Winamp, your notice they use fancy looking buttons and that they don’t use the standard rectangular windows your used to seeing with Windows. These tutorials aim to teach you how to make your standard Windows GUI application look more visually appealing.



Q. What are the drawbacks?

More of an annoyance than a drawback, should the end user of your application be using a non standard Windows theme, then your application wont match there theme, which may be a minus in some case’s.



Q. What will I need to know to keep up with this tutorial?

This tutorial assumes you have a decent knowledge of creating GUI’s using dialogs or the standard win32 API in C\C++. It also assumes you have a working knowledge of C\C++.



Ok lets get started with create non-rectangular windows.



Firstly there are two to ways to create non-rectangular windows, the first involves using regions and the second involves using layered windows, we can do two things using layered windows.



Firstly we can make whole windows transparent (see figure 1.1), secondly we can make a certain pixel colour in our window transparent\invisible (see figure 1.2), we can do this using the following windows API call:

CODE

SetLayeredWindowAttributes(HWND hWnd, COLORREF crKey, BYTE bAlpha, DWORD dwFlags);

Figure 1.1. Example of using transparent windows, note the calculator.





Figure 1.2. Example of making a single pixel colour invisible.





Note: the SetLayeredWindowAttributes(…) function is not compatible with Windows 98 and below.



What about regions?



I chose to keep this tutorial simple, regions are mainly used for backward compatibly should you use windows 98 or below. So I opted not to cover them in this tutorial.



Note: regions are also used to create non-rectangular buttons; I will cover this in part 3 of these tutorials.



Shall we start coding?



Not yet, were nearly there though, “No pain no gain”…

There are a few things you need understand before you can start using the SetLayeredWindowAttributes(…) function.



Firstly we need to load the function from User32.dll so our code will run on Win9x machines (otherwise export will fail and our application may crash).

But before we can load the function we must declare it:

CODE

// defines, we will need these later

#define LWA_COLORKEY            0x00000001

#define LWA_ALPHA               0x00000002

#define g_ColourKey         0xFF00FF // 0,0,255(pink) in RGB hex value



// declare the function

typedef BOOL (WINAPI *lpfnSetLayeredWindowAttributes)(HWND hWnd, COLORREF crKey, BYTE bAlpha, DWORD dwFlags);

lpfnSetLayeredWindowAttributes SetLayeredWindowAttributes;



// NOTE: this code goes above main() …

Now we need to import the function:

CODE

// get a handle to the DLL

HMODULE hUser32 = GetModuleHandle(("USER32.DLL"));



// get pointer to function from DLL  

SetLayeredWindowAttributes = (lpfnSetLayeredWindowAttributes)GetProcAddress(hUser32, "SetLayeredWindowAttributes");



// error importing function   

if(SetLayeredWindowAttributes == NULL)

        MessageBox(0, "Error importing function", "Error!", MB_ICONSTOP | MB_OK);           



// NOTE: this code goes just after main()

So to recap, we have now declared and imported our function, time to start using it.



To use layered windows we need to give our window an extended window style, that being the following:

CODE

WS_EX_LAYERED

To set this style on our window we need to add the following code into our GUI’s WM_INITDIALOG or WM_CREATE message, depending if your using dialogs or not.



The code:

CODE

if(SetLayeredWindowAttributes != NULL)

               {

                SetWindowLong(hwnd, GWL_EXSTYLE, GetWindowLong(hwnd, GWL_EXSTYLE) | WS_EX_LAYERED);

               }

Done that? Good.



Now we need to actually to make our window layered, we can do this using the following code:

CODE

SetLayeredWindowAttributes(hwnd, g_ColourKey, 0, LWA_COLORKEY);

/* NOTE: put this code into the “if(SetLayeredWindowAttributes != NULL)” statement */

After you call this function any pixels with an RGB value of 0,0,255 will become invisible. If your using dialogs your WM_INITDIALOG message should look like this:

CODE

case WM_INITDIALOG:

          {

            if(SetLayeredWindowAttributes != NULL)

            {

              SetWindowLong(hwnd, GWL_EXSTYLE, GetWindowLong(hwnd, GWL_EXSTYLE) | WS_EX_LAYERED);

              SetLayeredWindowAttributes(hwnd, g_ColourKey, 0, LWA_COLORKEY);

            }    

           

            break;

          }.

Ok so we have managed to make any pixel with an RGB value of 0,0,255 invisible, lets make this useful. We will need to find a nice background for our application; I chose to use this (see figure 1.3). Note I did not make it, I just edited it.



Figure 1.3, Example background.







Note the pink, remember our code makes pink pixels transparent, so we know have nice skin and a non-rectangular window… Well we should have, but there is a little bit more work to do.



We have declared our function, we have imported it, we have set our windows style to layered, we have told our window to make any pixels with an RGB value of 0,0,255 invisible… All we need to do now is load and draw the bitmap (our skin), which isn’t to hard. Save your skin as skin.bmp.

Ok so first we need to make the bitmap a resource, in your projects directory create a 2 files, one called Res.rc and the second called Res.h,. Res.rc is our resource file, we will make our bitmap a resource using this file, the 2nd is used to declare our resource so our main application can see it. Lets begin.



Open Res.rc and add the following code:

CODE

IDB_SKIN BITMAP DISCARDABLE "skin.bmp"

Ok our bitmap is now included as a resource in our application, we now need to declare it in Res.h.



Open Res.h and add the following code:

CODE

#define IDB_SKIN 1001

Now in your main project’s file add:

CODE

#include “res.h”

Into the includes section.



You now have your bitmap contained in your file as a resource, lets load it and start using it in our application.



To load a bitmap we need to use the LoadBitmap() function, which looks like this:

CODE

HBITMAP LoadBitmap(

  HINSTANCE hInstance,  // handle to application instance

  LPCTSTR lpBitmapName  // name of bitmap resource

);

and its description:

QUOTE

The LoadBitmap function loads the specified bitmap resource from a module's executable file. This function has been superseded by the LoadImage function.

Ok so once we load our bitmap we need to get a handle to it, a bitmap has a special type of handle, which is known as “HBITMAP”. Lets see some code.

To load our bitmap:

CODE

// OTHER CODE HERE

HBITMAP hSkinMBmp = NULL; // note: this is a global variable

// OTHER CODE HERE



// ENTRY POINT (WinMain())



  hSkinMBmp = LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_SKIN));     

            if(hSkinMBmp == NULL)  

            {                                                         

             MessageBox(0, "Could not load Skin", "Warning", MB_OK |   MB_ICONEXCLAMATION);

            }

Pretty easy isn’t it… All that’s left is to draw our bitmap.



Scroll through your main source file until you reach your dialogs callback function.



We need to add a WM_PAINT message to the dialog, this message is sent every time the dialog redraws itself, so we need to tell the dialog to draw the bitmap, here is my WM_PAINT implementation:

CODE

   case WM_PAINT:

           {

            BITMAP bm;

            PAINTSTRUCT ps;

            HDC hdc = BeginPaint(hwnd, &ps);

            HDC dcSkin = CreateCompatibleDC(hdc);

            GetObject(hSkinMBmp, sizeof(bm), &bm);

            SelectObject(dcSkin, hSkinMBmp);

            BitBlt(hdc, 0,0,500,500, dcSkin, 0, 0, SRCCOPY);

            DeleteDC(dcSkin);

            EndPaint(hwnd, &ps);

            break;

           }

once more thing we need to do is destroy our windows caption bars and make it non-resizable, I wrote this function to do it for us:

CODE

void DestroyCaption(HWND hwnd, int windowWidth, int windowLentgh)

{

HWND hWnd = hwnd;

DWORD dwStyle = GetWindowLong(hWnd, GWL_STYLE);

dwStyle &= ~(WS_CAPTION|WS_SIZEBOX);

SetWindowLong(hWnd, GWL_STYLE, dwStyle);

InvalidateRect(hWnd, NULL, TRUE);

SetWindowPos(hWnd, NULL, 0,0,windowWidth, windowLentgh, SWP_NOMOVE | SWP_NOZORDER); 

}

If you thought about what I just said you may be thinking how would I move my window if there was no caption bar? To do this we need to add one more message to our dialogs callback rouitine, see the code below:

CODE

case WM_LBUTTONDOWN:

           {

            PostMessage(hwnd, WM_NCLBUTTONDOWN, HTCAPTION,NULL);

            break;

           }

This makes our window think we our clicking the caption bar no matter where we click on it, so it means we can drag the window by clicking anywhere on it.



Ok the last thing we need to do is clear up, this is simple, in your dialogs WM_CLOSE message add a call to “DeleteObject(hSkinMBmp);”.



Your WM_CLOSE message should look like this:

CODE

  case WM_CLOSE:

           {    

            DeleteObject(hSkinMBmp);

            EndDialog(hwnd, 0);

            break;

           }

Ok your now finally done, it was a lot of hard work I know, but you did it, you can now create non-rectangular windows and impress your friends with your better looking than there’s GUI (lol). Just in case you had trouble piecing together all the source in this tutorial, I wrote a complete example in Dev-CPP, you can find the download link below. Well I hope you enjoyed this tutorial, I know I missed a few details but I wanted to keep it simple, I will expand on what you have learnt here in part 2 of this tutorial. Any comments, questions just let me know, KOrUPt .





Source code download link:

http://rapidshare.com/files/66820612/Skinn...xample.rar.html

Read More

how to turn Vista into a Mac

Got the dock by installing ObjectDock.

http://www.download.com/3001-2341_4-106962...c197a91968dbd29



The MSN theme was a skin for the Messenger Plus package.

http://www.msgpluslive.net/

http://www.msgpluslive.net/skins/view/7-Ap...Live-Messenger/



And the theme I was using is this one (see below for the patcher to make it work)

http://zeusosx.deviantart.com/art/WIN-ZEUS...-VISTA-68544169



I actually used a program called VistaGlazz to patch these DLL's for me.

http://www.codegazer.com/vistaglazz/



I will probably change the dock style later but its fine for me at the moment :]



And thats all you need.

Read More

Assembly tutorial, The basics, enough to get started

Here is a basic rundown of how assembly language works, some of the registers, some of the commands, and enough to keep you (hopefully) occupied for a while.



~~~HOW IT WORKS~~~

You push and pop and otherwise move pieces of memory into different places, through various ports, and send them onto different routines. In the long run, it all comes together to process information, get user in/output, and make the most of your clock cycles.



~~~REGISTERS~~~



These are your bread and butter. Last time I checked there were about 30 of these, and I'm going to brush over them here:



EAX,EBX,ECX,EDX - These are all-purpose registers. They are each 32 bits wide (DWORD) and can be broken down further eg EAX is all 32 bits, AX is the 16 least significant bits, and breaks down into AH and AL (H=high and L=low). This can be done with all four of these registers.



Traditionally they have all had different uses, although this has been relaxed in later years.



EAX is the Accumulator, and holds the return value from a function (by convention, not automatically so you need to put your return value here yourself). In 16-bit OS's, AX is used for interrupt subfunctions, but the bottom line here is that when you call a function you can usually count on whatever value was in this register beforehand being destroyed, and naturally you can do whatever you want with it in your programs too. If you want to read/write from memory to a register quickly, you can use LODSB/STOSB/LODSW/STOSW to move from memory pointed to by ESI to an A-series register, or from there to the location of EDI. EAX is also used in the MUL and DIV commands. If you are interested in saving space in your applications, some opcodes have special-case EAX versions, so in short MOV EAX,value is shorter than MOV EBX,value if I remember rightly, somebody please point out if I'm wrong here.



ECX is the Counter, and as a result has a variety of functions related to it with counting in mind. The most common in 16-bit days was the LOOP command, which decremented CX and jumped to the place given if CX!=1. It is also used with JCXZ/JCXNZ and REP. ECX is also a "garbage" register - you cannot count on it being untouched after calling a function, and you can in turn do what you want with it.



EDX is the Data register. It is similar to EAX, but not nearly as widely used. The D-series registers deal with the overflow from the MUL and DIV commands. EDX is also "garbage", so the same rules apply to its use as to ECX and EAX.



EBX is a weird register. On 16-bit processors it was the only general purpose register that could be used to reference memory, although on 32-bit processors and general purpose register can be used - EBX is conventional though. As a result, BX is sometimes passed to 16-bit interrupts as an offset pointer. EBX is NOT a garbage register, so if you intend to use it in your function be sure to save its original state, because even in windows 98 changing its value can crash your program. Because of this I try to avoid this register as much as possible, unless I really need the extra register.





ESI, EDI, ESP, EBP - Addressing registers. All of these can be referred to by their 16-bit names aswell



ESI is the Source register, and points to the data source in LODSB/W and MOVSB/W. It is not a garbage register, so while you should preserve its original state data can be safely left in it when calling other functions.



EDI is the Destination register, points to the data destination in STOSB/W and MOVSB/W. Apart from this it is identical to ESI.



ESP is the Stack pointer. Every time you PUSH a piece of data, ESP is decremented the appropriate amount and your value is stored at the new ESP. In real mode SP is used instead. DO NOT TOUCH THIS REGISTER.



EBP should not be touched unless you know what you're doing. With many high level languages which use stack-based local variables, ESP is decremented a certain amount to create space for local variables and the original ESP is stored in EBP. As EBP may have contained useful data it is pushed onto the stack before any of this happens, so as a result the entire process is reversible. (Side note: because of how these local variables are stored, and the fact that when a function is called the address of the calling opcode is stored in the stack, if a buffer is contained in local memory that is not length-checked, it is possible for code to be injected there, followed by the address of the injectable code as the offset of the return function is overwritten.)





CS, DS, ES, FS, GS, SS - Segment registers.

In 16-bit OS's, there were originally only CS, DS and ES, and the segments were simple - each could be multiplied by 0x10 (16) and added to the offset of any addressed data to find the physical memory address. However with 32-bit cpus and the introduction of protected mode, the segment registers now just refer to segment descriptors, which are structures containing information about the address of the segment, size of the segment, rights within the segment (readable, writeable, executable etc). CS is the code segment, and CS:EIP (or IP in 16-bit) points to the current instruction. DS is the data segment, and is used with (E)SI as ES (Extra segment) is used with (E)DI for LOD/STO/MOV SB commands. It should be noted that DS is the default segment if you don't specify one when moving data around, eg MOV EAX,[EDI] will load EAX with the dword at DS:EDI. ES,FS,GS are all "extra" segments, as in they can be used as placeholders for segments that aren't used particularly often. I may be wrong here (someone point this out if I am) but I'm pretty sure there is no opcode to move a data constant or even a piece from memory directly into a segment register, so you need to POP it off the stack, or MOV from another register. It should be pointed out also that these are not Extended as the other registers are, but are rather 16-bits wide for each register. SS is used in conjuntion with (E)SP for PUSHes and POPs, so should also not be touched AT ALL.





As well as these registers, which are most commonly used (except for segment registers which are never used for usermode 32-bit apps) there are a few more special purpose registers such as cr0 which is used for protected mode related stuff. There are also FPU registers which are manipulated by the arithmetic coprocessor, but there are tutorials on those specifically, including one which comes with the masm32 package. These ones I've mentioned should be the only ones that you really need to use.





~~~COMMANDS~~~

These are known as "opcodes" because unlike commands in other languages, these don't call different procedures but are the actual messages that get sent directly to the CPU. Here's a few everyday ones to get you started:





MOV - moves data from memory to register, register to register, constant to register, register to memory. Cannot be used to move from memory to memory directly. If you want to set a register to 0 it is conventional to use XOR EAX,EAX (eg setting eax to zero) as it is smaller and slightly faster.



Syntax: MOV destination,source



Both arguments must be of the same width, eg MOV AX,EBX will not work.





CALL - calls a subroutine

If you use nasm or masm, you'll find the INVOKE macro used often. What this does is PUSHes all the arguments onto the stack in reverse order, and then CALLs the function requested. Note that this is a macro, and when assembled is converted into the PUSHes and CALL that make up the instruction.



Syntax: CALL label





RET - return from subroutine



Syntax: RET





PUSH - pushes a value, point in memory, or register onto the stack. This is often used to preserve registers that aren't allowed to be destroyed, and also for passing arguments onto a function.



Syntax: PUSH value/register/memory reference





POP - pops a value off the stack into a point in memory or register. The opposite of PUSH, and usually symmetrical to PUSH, as often if a register is to be preserved with PUSH EBX you can find POP EBX later in the function.



Syntax: POP value/register/memory reference





CMP - compares two registers, or a register and a value (fixme - may work with memory refs?)

This is what makes programs dynamic - the ability to do If and Else statements. This also works with loops if you're using unoptimised code. When it returns it sets various flags, which can be added onto variables or used with the conditional jump commands. If you want to compare a register to 0 it is also conventional to use OR register,register which I think may be slightly quicker.



Syntax: CMP value1,value2





JMP - Jump to a label

In 32-bit programming it doesn't matter whether a jump is far or near, so JMP is used for all purposes, however in 16-bit programming the difference between a near jump and a far jump is quite a lot because a near jump can only reference 16 bits either side of your opcode, so jumping to another segment requires a FAR JUMP which includes the segment of the new routine.



Syntax: JMP label





JE, JNE, JG, JL, JGE, JLE, JZ, JNZ - Conditional jumps

JZ and JE are the same, as are JNZ and JNE, but have different meanings, as JZ will jump if the zero flag is set, but JE will jump if the values are equal (and so the zero flag gets set meaning they are essentially the same). Which one you use is completely up to you, as they assemble to the same machine code. Also to be noted are JG, JL, JGE and JLE which are jump if greater, jump if less than, jump if greater than/equal to, and jump if less than/equal to. Note that these compare the first value of the CMP command to the second, so CMP v1,v2 JG label is the same as if(v1>v2) goto label; Also note that these have synonyms which are JA, JB, JAE and JBE which in this case have DIFFERENT assembled values as they compare different flags to produce what as far as I can tell are the same result. To make this more confusing, there are also opposites, eg JNB (jump if not below), JNG, JNGE which assemble to the same machine code commands as their counterparts, eg JNB is the same as JAE etc. There are also other commands that test individual flags which can be used for different purposes (eg testing OF the overflow flag to see if an addition has overflowed off the end) which are all fairly self-explanitory. These can all be near or short jumps, and should be assembled differently depending on where the labels are in your program.



Syntax: same as for JMP







~~~ASSEMBLERS~~~

These come in different shapes and sizes, fulfil different purposes, and most of all use slightly different syntax (with the exception of mingw/dev-cpp inline asm which is just weird). Nasm is a free open source assembler with simplified structure support and very well defined means for addressing, masm has better structure support, more macros, and is helpful when making the step between C and asm. Tasm is a lot older than both of these, and as far as I know is used more for console apps. Fasm is one I have heard much about, but never really played with much.



The bottom line here is that it doesn't matter what assembler you use, as long as you like it, and you know the differences between it and the other major assemblers for when you get code samples.





~~~CONCLUSION~~~



I'm hoping this is enough for now, post here if theres anything ive missed or badly fucked up and ill see to it that it gets fixed





All for now



NoFriLLz

Read More

MultiInjector - Automated Stealth SQL Injection Tool

MultiInjector claims to the first configurable automatic website defacement software, I’m not sure if that’s a good thing - or a bad thing.

But well here it is anyway.



Features

• Receives a list of URLs as input


• Recognizes the parameterized URLs from the list


• Fuzzes all URL parameters to concatenate the desired payload once an injection is successful


• Automatic defacement - you decide on the defacement content, be it a hidden script, or just pure old “cyber graffiti” fun


• OS command execution - remote enabling of XP_CMDSHELL on SQL server, subsequently running any arbitrary operating system command lines entered by the user


• Configurable parallel connections exponentially speed up the attack process - one payload, multiple targets, simultaneous attacks


• Optional use of an HTTP proxy to mask the origin of the attacks

The author highly recommend running a HTTP sniffer such as IEInspector HTTP Analyzer in order to see all attack requests going out to the targets.

Requirements

• Python >= 2.4


• Pycurl (compatible with the above version of Python)


• Psyco (compatible with the above version of Python)

You can download MultiInjector v0.2 here:

MultiInjector.py

Or read more here.

Read More

Free ISO Creator Makes Disk Images Fast and Painless

Windows only: Create ISO-format disk images quickly and easily with Free ISO Creator. After downloading and installing the software, all you have to do is click Add File(s) or Add Folder to choose the data you want included in the image, select a name and location for the ISO file with "Save ISO As..." and click Convert. You can even create a bootable disk image by clicking Options and selecting the appropriate IMG file. Now you can burn the image to disk with ISO Recorder or mount the image as a virtual drive in Windows with the Virtual CD-ROM Control Panel, Clonedrive or Daemon Tools. Free ISO Creator is a free download for Windows.

Free ISO Creator [via Download Squad]

Read More