Posts from the ‘Uncategorized’ Category

Inside Windows Product Activation – Algorithm Explanation

The current public discussion of Windows Product Activation (WPA) is

characterized by uncertainty and speculation. In this paper we supply

the technical details of WPA – as implemented in Windows XP – that

Microsoft should have published long ago.

While we strongly believe that every software vendor has the right to

enforce the licensing terms governing the use of a piece of licensed

software by technical means, we also do believe that each individual

has the right to detailed knowledge about the full implications of the

employed means and possible limitations imposed by it on software

usage.

In this paper we answer what we think are currently the two most

important open questions related to Windows Product Activation.

* Exactly what information is transmitted during activation?

* How do hardware modifications affect an already activated

installation of Windows XP?

Our answers to these questions are based on Windows XP Release

Candidate 1 (build 2505). Later builds as well as the final version of

Windows XP might differ from build 2505, e.g. in the employed

cryptographic keys or the layout of some of the data

structures.

However, beyond such minor modifications we expect Microsoft to cling

to the general architecture of their activation mechanism. Thus, we

are convinced that the answers provided by this paper will still be

useful when the final version of Windows XP ships.

This paper supplies in-depth technical information about the inner

workings of WPA. Still, the discussion is a little vague at some

points in order not to facilitate the task of an attacker attempting

to circumvent the license enforcement supplied by the activation

mechanism.

XPDec, a command line utility suitable for verifying the presented

information, can be obtained from http://www.licenturion.com/xp/. It

implements the algorithms presented in this paper. Reading its source

code, which is available from the same location, is highly

recommended.

We have removed an important cryptographic key from the XPDec source

code. Recompiling the source code will thus fail to produce a working

executable. The XPDec executable on our website, however, contains

this key and is fully functional.

So, download the source code to learn about the inner workings of WPA,

but obtain the executable to experiment with your installation of

Windows XP.

We expect the reader to be familiar with the general procedure of

Windows Product Activation.

>> INSIDE THE INSTALLATION ID

We focused our research on product activation via telephone. We did

so, because we expected this variant of activation to be the most

straight-forward to analyze.

The first step in activating Windows XP via telephone is supplying the

call-center agent with the Installation ID displayed by msoobe.exe,

the application that guides a user through the activation process. The

Installation ID is a number consisting of 50 decimal digits that are

divided into groups of six digits each, as in

002666-077894-484890-114573-XXXXXX-XXXXXX-XXXXXX-XXXXXX-XX

In this authentic Installation ID we have substituted digits that we

prefer not to disclose by ‘X’ characters.

If msoobe.exe is invoked more than once, it provides a different

Installation ID each time.

In return, the call-center agent provides a Confirmation ID matching

the given Installation ID. Entering the Confirmation ID completes the

activation process.

Since the Installation ID is the only piece of information revealed

during activation, the above question concerning the information

transmitted during the activation process is equivalent to the

question

‘How is the Installation ID generated?’

To find an answer to this question, we trace back each digit of the

Installation ID to its origins.

>>> Check digits

The rightmost digit in each of the groups is a check digit to guard

against simple errors such as the call center agent’s mistyping of one

of the digits read to him or her. The value of the check digit is

calculated by adding the other five digits in the group, adding the

digits at even positions a second time, and dividing the sum by

seven. The remainder of the division is the value of the check

digit. In the above example the check digit for the first group (6) is

calculated as follows.

1 | 2 | 3 | 4 | 5 <- position

—+—+—+—+—

0 | 0 | 2 | 6 | 6 <- digits

0 + 0 + 2 + 6 + 6 = 14 (step 1: add all digits)

0 + 6 + 14 = 20 (step 2: add even digits again)

step 3: division

20 / 7 = 2, remainder is 20 – (2 * 7) = 6

=> check digit is 6

Adding the even digits twice is probably intended to guard against the

relatively frequent error of accidentally swapping two digits while

typing, as in 00626 vs. 00266, which yield different check digits.

>>> Decoding

Removing the check digits results in a 41-digit decimal number. A

decimal number of this length roughly corresponds to a 136-bit binary

number. In fact, the 41-digit number is just the decimal encoding of

such a 136-bit multi-precision integer, which is stored in little

endian byte order as a byte array. Hence, the above Installation ID

can also be represented as a sequence of 17 bytes as in

0xXX 0xXX 0xXX 0xXX 0xXX 0xXX 0xXX 0xXX

0x94 0xAA 0x46 0xD6 0x0F 0xBD 0x2C 0xC8

0x00

In this representation of the above Installation ID ‘X’ characters

again substitute the digits that we prefer not to disclose. The ‘0x’

prefix denotes hex notation throughout this paper.

>>> Decryption

When decoding arbitrary Installation IDs it can be noticed that the

most significant byte always seems to be 0x00 or 0x01, whereas the

other bytes look random. The reason for this is that the lower 16

bytes of the Installation ID are encrypted, whereas the most

significant byte is kept in plaintext.

The cryptographic algorithm employed to encrypt the Installation ID is

a proprietary four-round Feistel cipher. Since the block of input

bytes passed to a Feistel cipher is divided into two blocks of equal

size, this class of ciphers is typically applied to input blocks

consisting of an even number of bytes – in this case the lower 16 of

the 17 input bytes. The round function of the cipher is the SHA-1

message digest algorithm keyed with a four-byte sequence.

Let + denote the concatenation of two byte sequences, ^ the XOR

operation, L and R the left and right eight-byte input half for one

round, L’ and R’ the output halves of said round, and First-8() a

function that returns the first eight bytes of an SHA-1 message

digest. Then one round of decryption looks as follows.

L’ = R ^ First-8(SHA-1(L + Key))

R’ = L

The result of the decryption is 16 bytes of plaintext, which are –

together with the 17th unencrypted byte – from now on interpreted as

four double words in little endian byte order followed by a single

byte as in

name | size | offset

—–+————-+——-

H1 | double word | 0

H2 | double word | 4

P1 | double word | 8

P2 | double word | 12

P3 | byte | 16

H1 and H2 specify the hardware configuration that the Installation ID

is linked to. P1 and P2 as well as the remaining byte P3 contain the

Product ID associated with the Installation ID.

>>> Product ID

The Product ID consists of five groups of decimal digits, as in

AAAAA-BBB-CCCCCCC-DDEEE

If you search your registry for a value named ‘ProductID’, you will

discover the ID that applies to your installation. The ‘About’ window

of Internet Explorer should also yield your Product ID.

>>>> Decoding

The mapping between the Product ID in decimal representation and its

binary encoding in the double words P1 and P2 and the byte P3 is

summarized in the following table.

digits | length | encoding

——–+———+—————————————

AAAAA | 17 bits | bit 0 to bit 16 of P1

BBB | 10 bits | bit 17 to bit 26 of P1

CCCCCCC | 28 bits | bit 27 to bit 31 of P1 (lower 5 bits)

| | bit 0 to bit 22 of P2 (upper 23 bits)

DDEEE | 17 bits | bit 23 to bit 31 of P2 (lower 9 bits)

| | bit 0 to bit 7 of P3 (upper 8 bits)

The meaning of each of the five groups of digits is documented in the

next table.

digits | meaning

——–+————————————————-

AAAAA | apparently always 55034 (in Windows XP RC1)

BBB | most significant three digits of Raw Product Key

| (see below)

CCCCCCC | least significant six digits of Raw Product Key

| plus check digit (see below)

DD | index of the public key used to verify the

| Product Key (see below)

EEE | random value

As can be seen, the (Raw) Product Key plays an important role in

generating the Product ID.

>>>> Product Key

The Raw Product Key is buried inside the Product Key that is printed

on the sticker distributed with each Windows XP CD. It consists of

five alphanumeric strings separated by ‘-‘ characters, where each

string is composed of five characters, as in

FFFFF-GGGGG-HHHHH-JJJJJ-KKKKK

Each character is one of the following 24 letters and digits:

B C D F G H J K M P Q R T V W X Y 2 3 4 6 7 8 9

Very similar to the decimal encoding of the Installation ID the 25

characters of the Product Key form a base-24 encoding of the binary

representation of the Product Key. Decoding the Product Key yields a

multi-precision integer of roughly 115 bits, which is stored – again

in little endian byte order – in an array of 15 bytes. Decoding the

above Product Key results in the following byte sequence.

0x6F 0xFA 0x95 0x45 0xFC 0x75 0xB5 0x52

0xBB 0xEF 0xB1 0x17 0xDA 0xCD 0x00

Of these 15 bytes the least significant four bytes contain the Raw

Product Key in little endian byte order. The least significant bit is

removed by shifting this 32-bit value (0x4595FA6F – remember the

little endian byte order) to the left by one bit position, resulting

in a Raw Product Key of 0x22CAFD37, or

583728439

in decimal notation.

The eleven remaining bytes form a digital signature, allowing

verification of the authenticity of the Product Key by means of a

hard-coded public key.

>>>> Product Key -> Product ID

The three most significant digits, i.e. 583, of the Raw Product Key’s

nine-digit decimal representation directly map to the BBB component of

the Product ID described above.

To obtain the CCCCCCC component, a check digit is appended to the

remaining six digits 728439. The check digit is chosen such that the

sum of all digits – including the check digit – is divisible by

seven. In the given case, the sum of the six digits is

7 + 2 + 8 + 4 + 3 + 9 = 33

which results in a check digit of 2, since

7 + 2 + 8 + 4 + 3 + 9 + 2 = 33 + 2 = 35

which is divisible by seven. The CCCCCCC component of the Product ID

is therefore 7284392.

For verifying a Product Key, more than one public key is available. If

verification with the first public key fails, the second is tried,

etc. The DD component of the Product ID specifies which of the public

keys in this sequence was successfully used to verify the Product Key.

This mechanism might be intended to support several different parties

generating valid Product Keys with different individual private keys.

However, the different private keys might also represent different

versions of a product. A Product Key for the ‘professional’ release

could then be signed with a different key than a Product Key for the

‘server’ release. The DD component would then represent the product

version.

Finally, a valid Product ID derived from our example Product Key might

be

55034-583-7284392-00123

which indicates that the first public key (DD = index = 0) matched and

123 was chosen as the random number EEE.

The randomly selected EEE component is the reason for msoobe.exe

presenting a different Installation ID at each invocation. Because of

the applied encryption this small change results in a completely

different Installation ID.

So, the Product ID transmitted during activation will most probably

differ in the last three digits from your Product ID as displayed by

Internet Explorer or as stored in the registry.

>>> Hardware Information

As discussed above, the hardware configuration linked to the

Installation ID is represented by the two double words H1 and H2.

>>>> Bit-fields

For this purpose, the double words are divided into twelve

bit-fields. The relationship between the computer hardware and the

bit-fields is given in the following table.

double word | offset | length | bit-field value based on

————+——–+——–+—————————-

H1 | 0 | 10 | volume serial number string

| | | of system volume

H1 | 10 | 10 | network adapter MAC address

| | | string

H1 | 20 | 7 | CD-ROM drive hardware

| | | identification string

H1 | 27 | 5 | graphics adapter hardware

| | | identification string

H2 | 0 | 3 | unused, set to 001

H2 | 3 | 6 | CPU serial number string

H2 | 9 | 7 | harddrive hardware

| | | identification string

H2 | 16 | 5 | SCSI host adapter hardware

| | | identification string

H2 | 21 | 4 | IDE controller hardware

| | | identification string

H2 | 25 | 3 | processor model string

H2 | 28 | 3 | RAM size

H2 | 31 | 1 | 1 = dockable

| | | 0 = not dockable

Bit 31 of H2 specifies, whether the bit-fields represent a notebook

computer that supports a docking station. If docking is possible, the

activation mechanism will be more tolerant with respect to future

hardware modifications. Here, the idea is that plugging a notebook

into its docking station possibly results in changes to its hardware

configuration, e.g. a SCSI host adapter built into the docking station

may become available.

Bits 2 through 0 of H2 are unused and always set to 001.

If the hardware component corresponding to one of the remaining ten

bit-fields is present, the respective bit-field contains a non-zero

value describing the component. A value of zero marks the hardware

component as not present.

All hardware components are identified by a hardware identification

string obtained from the registry. Hashing this string provides the

value for the corresponding bit-field.

>>>> Hashing

The hash result is obtained by feeding the hardware identification

string into the MD5 message digest algorithm and picking the number of

bits required for a bit-field from predetermined locations in the

resulting message digest. Different predetermined locations are used

for different bit-fields. In addition, a hash result of zero is

avoided by calculating

Hash = (Hash % BitFieldMax) + 1

where BitFieldMax is the maximal value that may be stored in the

bit-field in question, e.g. 1023 for a 10-bit bit-field, and ‘x % y’

denotes the remainder of the division of x by y. This results in

values between 1 and BitFieldMax. The obtained value is then stored in

the respective bit-field.

>>>> RAM bit-field

The bit-field related to the amount of RAM available to the operating

system is calculated differently. The seven valid values specify the

approximate amount of available RAM as documented in the following

table.

value | amount of RAM available

——+—————————

0 | (bit-field unused)

1 | below 32 MB

2 | between 32 MB and 63 MB

3 | between 64 MB and 127 MB

4 | between 128 MB and 255 MB

5 | between 256 MB and 511 MB

6 | between 512 MB and 1023 MB

7 | above 1023 MB

It is important to note that the amount of RAM is retrieved by calling

the GlobalMemoryStatus() function, which reports a few hundred

kilobytes less than the amount of RAM physically installed. So, 128 MB

of RAM would typically be classified as “between 64 MB and 127 MB”.

>>>> Real-world example

Let us have a look at a real-world example. On one of our test systems

the hardware information consists of the following eight bytes.

0xC5 0x95 0x12 0xAC 0x01 0x6E 0x2C 0x32

Converting the bytes into H1 and H2, we obtain

H1 = 0xAC1295C5 and H2 = 0x322C6E01

Splitting H1 and H2 yields the next table in which we give the value

of each of the bit-fields and the information from which each value is

derived.

dw & | |

offset | value | derived from

——-+——-+———————————————–

H1 0 | 0x1C5 | ‘1234-ABCD’

H1 10 | 0x0A5 | ’00C0DF089E44′

H1 20 | 0x37 | ‘SCSI\CDROMPLEXTOR_CD-ROM_PX-32TS__1.01’

H1 27 | 0x15 | ‘PCI\VEN_102B&DEV_0519&SUBSYS_00000000&REV_01’

H2 0 | 0x1 | (unused, always 0x1)

H2 3 | 0x00 | (CPU serial number not present)

H2 9 | 0x37 | ‘SCSI\DISKIBM_____DCAS-34330______S65A’

H2 16 | 0x0C | ‘PCI\VEN_9004&DEV_7178&SUBSYS_00000000&REV_03’

H2 21 | 0x1 | ‘PCI\VEN_8086&DEV_7111&SUBSYS_00000000&REV_01’

H2 25 | 0x1 | ‘GenuineIntel Family 6 Model 3’

H2 28 | 0x3 | (system has 128 MB of RAM)

H2 31 | 0x0 | (system is not dockable)

>>> Using XPDec

XPDec is a utility to be run from the command prompt. It may be

invoked with one of four command line options to carry out one of four

tasks.

>>>> XPDec -i

This option enables you to access the information hidden in an

Installation ID. It decodes the Installation ID, decrypts it, and

displays the values of the hardware bit-fields as well as the Product

ID of your product. Keep in mind that the last three digits of the

Product ID contained in the Installation ID are randomly selected and

differ from the Product ID displayed by Internet Explorer.

The only argument needed for the ‘-i’ option is the Installation ID,

as in

XPDec -i 002666-077894-484890-114573-XXXXXX-XXXXXX-XXXXXX-XXXXXX-XX

>>>> XPDec -p

To help you trace the origin of your Product ID, this option decodes a

Product Key and displays the Raw Product Key as it would be used in a

Product ID.

The only argument needed for the ‘-p’ option is the Product Key, as in

XPDec -p FFFFF-GGGGG-HHHHH-JJJJJ-KKKKK

Note that this option does not verify the digital signature of the

Product Key.

>>>> XPDec -v

This option calculates the hash of a given volume serial number. It

was implemented to illustrate our description of string hashing. First

use ‘-i’ to display the hardware bit-fields. Then use this option to

verify our claims concerning the volume serial number hash.

The only argument needed for the ‘-v’ option is the volume serial

number of your system volume, as in

XPDec -v 1234-ABCD

(The volume serial number is part of the ‘dir’ command’s output.)

>>>> XPDec -m

This option calculates the network adapter bit-field value

corresponding to the given MAC address. Similar to ‘-v’ this option

was implemented as a proof of concept.

The only argument needed for the ‘-m’ option is the MAC address of

your network adapter, as in

XPDec -m 00-C0-DF-08-9E-44

(Use the ‘route print’ command to obtain the MAC address of your

network adapter.)

>> HARDWARE MODIFICATIONS

When looking at the effects of hardware modifications on an already

activated installation of Windows XP, the file ‘wpa.dbl’ in the

‘system32’ directory plays a central role. It is a simple

RC4-encrypted database that stores, among other things like expiration

information and the Confirmation ID of an activated installation,

a) the bit-field values representing the current hardware

configuration,

and

 the bit-field values representing the hardware configuration

at the time of product activation.

While a) is automatically updated each time the hardware configuration

is modified in order to reflect the changes,  remains fixed. Hence,
 can be thought of as a snapshot of the hardware configuration at

the time of product activation.

This snapshot does not exist in the database before product activation

and if we compare the size of ‘wpa.dbl’ before and after activation,

we will notice an increased file size. This is because the snapshot is

added to the database.

When judging whether re-activation is necessary, the bit-field values

of a) are compared to the bit-field values of , i.e. the current

hardware configuration is compared to the hardware configuration at

the time of activation.

>>> Non-dockable computer

Typically all bit-fields with the exception of the unused field and

the ‘dockable’ field are compared. If more than three of these ten

bit-fields have changed in a) since product activation, re-activation

is required.

This means, for example, that in our above real-world example, we

could replace the harddrive and the CD-ROM drive and substantially

upgrade our RAM without having to re-activate our Windows XP

installation.

However, if we completely re-installed Windows XP, the information in
 would be lost and we would have to re-activate our installation,

even if we had not changed our hardware.

>>> Dockable computer

If bit 31 of H2 indicates that our computer supports a docking

station, however, only seven of the ten bit-fields mentioned above are

compared. The bit-fields corresponding to the SCSI host adapter, the

IDE controller, and the graphics board are omitted. But again, of

these remaining seven bit-fields, only up to three may change without

requiring re-activation.

>> CONCLUSIONS

In this paper we have given a technical overview of Windows Product

Activation as implemented in Windows XP. We have shown what

information the data transmitted during product activation is derived

from and how hardware upgrades affect an already activated

installation.

Looking at the technical details of WPA, we do not think that it is as

problematic as many people have expected. We think so, because WPA is

tolerant with respect to hardware modifications. In addition, it is

likely that more than one hardware component map to a certain value

for a given bit-field. From the above real-world example we know that

the PX-32TS maps to the value 0x37 = 55. But there are probably many

other CD-ROM drives that map to the same value. Hence, it is

impossible to tell from the bit-field value whether it is a PX-32TS

that we are using or one of the other drives that map to the same

value.

In contrast to many critics of Windows Product Activation, we think

that WPA does not prevent typical hardware modifications and,

moreover, respects the user’s right to privacy.

>> ABOUT THE AUTHORS

Fully Licensed GmbH is a start-up company focusing on novel approaches

to online software licensing and distribution. Have a look at their

website at

http://www.licenturion.com

for more information.

Their research branch every now and then analyzes licensing solutions

implemented by other companies.

>> COPYRIGHT

Copyright © 2001 Fully Licensed GmbH (www.licenturion.com)

All rights reserved.

You are free to do whatever you want with this paper. However, you

have to supply the URL of its online version

http://www.licenturion.com/xp/

with any work derived from this paper to give credit to its authors.

All types of codes for making websites

Hidden Secret Service Codes for Chinese Mobile Phones

As we all know Chinese mobiles are getting BIG market in India and other countries. Here I’m sharing a few secret service codes for these Chinese mobiles. None of them was tested by me but all codes should work because these codes have been taken from a respected mobile manufacturer company: Enter into Engineering Mode: *#110*01# Enter into factory Mode: *#987# Restore Factory Settings: *#987*99# Check Software Version: *#900# OR *#800# Default User Codes: 1122, 3344, 1234, 5678 Change LCD Contrast: *#369# To Enable COM Port: *#110*01# -> Device -> Set UART -> PS Config -> UART1/115200 Codes to Change Screen Language:
*#0000# + Send : Set Default Language
*#0007# + Send : Set Language to Russian
*#0033# + Send : Set Language to French
*#0034# + Send : Set Language to Spanish
*#0039# + Send : Set Language to Italian
*#0044# + Send : Set Language to English
*#0049# + Send : Set Language to German
*#0066# + Send : Set Language to Thai
*#0084# + Send : Set Language to Vietnamese
*#0966# + Send : Set Language to Arabic

REVERSE CODING

# Released by Cybnet Security Group
# legalz: modify and use at will, if you make any changes, improvements, updates or use the code
# in another project, please send us what you did and give credit
# if you have any questions, post them at forum.hackerthreads.net
# be sure to check out hackerthreads.org for updates and new tutorials/downloads
Copyrights reserved to k33t, 2002 from CYBNET Security Group
—————————————————————————————————-
Index:
——-
1.Introduction
2.Disclaimer
3.Hexadecimal
4.RAM and ROM
5.ASM
6.Needed programs
7.Cracking
8.Conclusion
—————————
—Introduction———-
Welcome to my Reverse Coding tutorial! In this paper, you will
learn how to crack and modify your own software. I’ll try to get
into as much detail as possible, yet also dumb it down a bit. =)
——————————————————————————————————
—Disclaimer————
All information is purely for educational purposes only! The author
cannot be held responsible for any (ab)use of this information.
USE AT YOUR OWN RISK!!!
——————————————————————————————————
—Hexadecimal———-
To begin, I’m going to teach you about hexadecimal, so if you already
know it, then move on. Even if you do already know it, I suggest
sticking around for a refreshment of your memory.=)
Hexadecimal, or hex as it’s more commonly known, is a base 16
numbering system. Base 16 meaning that it consists of 16 numbers:
0-9 and A-F. Each of these numbers (A-F=10-16) have a value of 4 bits
and are also called nibbles. In representing a hexadecimal number, one
would write an “0x” before the actual bit set. 0x is simply a tag put
before a hex number to let programmers know that it is in fact, hex.
When writing hex, you will not need to use this prefix.
If you haven’t already noticed, the 0x prefix looks similar to that of exponential
notation. Actually this is where 0x has been derived, seeing as how
hex is simply a number that has been raised to a power of 16.
This means 10 in hexadecimal represents the value 16+0, or 16. So check
out this example:
0xB3 (hex)= 2*16(squared)+11*16(to the 1st power)+3*16(to the power of 0 )
=2*256+11*16+3=691 (decimal)
Yeah, you could do all of that, or you could be lazy and use an automated
program that does it all for you. Why do you need to know hex? Because
it’s used by every piece of software and hardware. How? Memory based address
allocation. Here’s an example:
When you clicked on your browsers icon to launch it, the click triggered a “call”
(an asm function that will be discussed more in depth in later chapters.) which
went back to the programs memory with the “click in it’s hand.” It finds the
address where the code is that makes the program launch and executes it. The
address is written in, you guessed it, hex. An example of an address would be
something like this:
101c5018
5108 would be the actual specific address and 101c would be the sector
of RAM were the address is located. Those are the basics of Hexadecimal
You should probley read this chapter againbecause getting a firm grasp on hex
is essential to cracking and moding programs.
———————————————————————————————————-
—RAM and ROM——–
In this section we are gonna learn about RAM and ROM. Many people kno about
the hardware part of RAM and ROM and that’s gonna be very useful to you……
just not in this tutorial. =) We are about to learn about the “software” side. I use the
term software loosly in that software tends to have a GUI (Graphical User Interface)
and this does not. BUT, there are ways to access and modify the behavior of it that
I will talk about in this chapter, as well as in the next. To start off, I’ll answer some
common questions:
What is RAM?
RAM (Random Access Memory) is basically memory and the process of accessing it.
The term “Random Access Memory” was approprietly given to this memory unit because
when executing a command, the CPU doesn’t have to scroll through all the memory on
your PC until it finds the right address. It “randomly” whips out the addy from it’s back
pocket and serves it up.This process is both quick and efficient. Learning this process
will help you understand the ASM functions in the next chapter.
How does RAM work?
When a command is issued and the memory is pulled from file, it must first go through
what is called a “vector”. A vector is a “gateway” or a “sector” of RAM where the address
of the function is stored with others of it’s own kind. An example of a vector would be
something like this:
8c0000b4-8c00ffff
This means that all “addressii” (hehe) that are between those values are stored in that
sector of RAM. A vector acts as a gateway in that, first, pass through a vector to get to
address. Your average program probley has about 30 to 40 main vectors, sectioning
off from boot until exit. Knowing the vector of an addy or a function will greatly reduce
your headache when you start searching for it.
ROM. ROM is a part of memory that doesn’t change. (Although we can change it.=) )
Boot ROM for instance, follows the same plan of action it is called upon. ROM also has
vectors, just like RAM. ROM is not that important when it comes to cracking to we will
leave it alone for now.
Back to RAM. Believe it or not, but addressii (there I go again, I’m such a g33k.)
actually follow certain formats or syntax’s for certain functions. Take hot keys for
example: In the under ground, we call them “Joker commands”. By pressing a certain
combonation of keys, a program will run, close, be stupid, whatever. The syntax for a
Joker command is as follows:
0d-aaaaaf
000zvvvv
Let’s examine this format a little closer.
0d= The proclemation of a specifyed format
aaaaa= The address of the function
f= The float or remainder; “Floating point number” ; decimal
000= “NOP” No operation
z= The “Booleon” as we the C++ programmers call it. A booleon is an “IF, THEN” statement.
“IF this is true, THEN do this.” Value 0= equal; 1= different; 2=less than; 3=greater than.
vvvv= The combonation of hex values (The values of the keys pressed) used to execute the “CALL”
Say the “A” key had a vlaue of fffb and the “B” key has a vlaue of fffd. You would then add both
values using a hex calculator and get fff9 as the sum. The output on you calculator would
show 1fff8. Add the first value and the last value to find the fourth byte segment. So say
we’ve found the address of the Joker function (usually in the boot ROM sector) commonly
called the “Maple address” and we are ready to program in some hex code. Our code may
look like this:
0d7ae671
0000fff9
This means that IF the value of fff9 (A and B) is equal (0) to the address (aaaaf) of the function,
THEN execute it. See? Easy isn’t it? You’ll need to know things like this when modding programs
as a use of executing of your arbitrary code in certain parts of your program at a certain time.
Joker commands are also reversable in that if you enter the same code except with a 1,2, or 3,
in the z slot and by changing the button combonations. Reversable meaning terminating the
function or other functions that were started. A good use for this is for firewalls and babysitting
programs. Are you on a college machine and can’t download stuff because of that pesky firewall?
Crack it open and program in some Joker commands so you can turn it on and off at will
WITHOUT the administrator’s password!
————————————————————————————————————–
—ASM———————–
To start off with our small and to the point ASM section, I’ll warn you in advance, after reading this,
you’ll need to go take a shower cause this is disgusting! Here we go!
To begin, I’m gonna define for you some functions that you’ll be seeing alot of, and be using. Here they are:
.:Hex:. .:ASM:. .:MEANING:.
75,0f85 jne jump if not equal
74,0f84 je jump is equal
eb jmp jump directly to
90 nop no operation
77,0f87 ja jump if above
0f86 jna jump if not above
0f83 jae jump if above or equal to
0f82 jnae jump if not above or equal
0f82 jb jump if below
0f83 jnb jump is not below
of86 jbe jump if below or equal
0f87 jnbe jump if not below or equal
0f8f jg jump if greater
0f8e jng jump if not greater
0f8d jge jump if greater or equal
0f8c jnge jump if not greater or equal
0f8c jl jump if less
0f8d jnl jump if not less
0f8e jle jump if less or equal
0f8f jnle jump if not less or equal
The easy thing about most of the functions in ASM are that they sound like what they mean.
Jump, means of coarse, to Jump from one thing to another. Example:
“jmp 00401744” would mean to jump directly to the address 00401744 once the code
hits the function.
Let’s look at “CALL”. Call is a function that is used to “call” a certain task, string, address, whatever.
Take a look at this example:
“Call 0040ccc2” this would of coarse call the address 0040ccc2 and use it. Those are the functions
you’ll be using.
The reason why I’m not going into loads of detail in this chapter is because when
cracking software, not an extensive amount of knowledge of ASM is needed. If you want
to know more or need help with something, e-mail me at the address provided at the end of
this tutorial. This chapter wasn’t so nasty was it? Nah, it was easy =)
————————————————————————————————————————
—Needed Programs—————-
The programs you will need are as follows:
WDasm 8.9 or Higher
Hiew 6.1
Softice for win9x v3.24
SubmitWolf(demo)v4.01 (http://www.trellian.com/swolf)
Programming Language (C,C++,Pascal,ASM whatever you would like) Prefably C for this tutorial!
And a brain (no seriously)
————————————————————————————————————————–
—Cracking—————————–

Ok, here we go! The first thing you need to do is to open up SoftIce and then swolf32.exe which is the name given to our
target program. Go to the help menu and select register. Here’s where your brain will come in, start to look
for how the protection is running by entering some random crap into the blank space. Don’t press the OK button yet though.
Instead, press CTRL-D to bring up SoftIce. What we are gonna try to do is define a breakpoint, using BPX hmemcpy.
Hit CTRL-D again and it will bring you back to the program. Click OK on the box and SoftIce will again pop up. Now press F12
and it will bring you to the target program code. Scroll down a few lines and find:
:004167D9 8D4C2410 lea ecx, dword ptr {esp+10}–;ecx=the random crap you typed in.
:004167DD 8D94290000000 lea edx, dword ptr {esp+00000090}-;edx=name
:004167E4 51 push ecx
:004167E5 52 push edx
:004167E6 E8B5450100 call 0042ADA0—-;this is the call which calculates the serial
:004167EB 83C410 add esp, 00000010–;
:004167EE 85C0 test eax, eax—-;and return eax=1 if true (booleon =) )
:004167F0 0F8596000000 jne 0041688C—-;jump to registered
:004167F6 8D442408 lea eax, dword ptr {esp+08}
:004167FA 8D8C2488000000 lea ecx, dword ptr {esp+00000088}
:00416801 50 push eax
:00416802 51 push ecx
:00416803 E868470100 call 0042AF70—-;this call tests our serial
:00416808 83C408 add esp, 00000008—;
:0041680B 85C0 test eax, eax—-;for v3.XX one.
:0041680D 7433 je 00416842;jump is equal
The call that we want to focas on is at 004167E6. This call tests wether our serial is for the correct version or not.
Let’s trace the call 004ADA0:
*Referenced by a CALL at address:
:0042ABFC
:0042ADA 83EC30 sub esp, 00000030
:0042ADA3 55 push ebp
:0042ASA4 56 push esi
:004ADA5 57 push edi
:0042ADA6 8B7C24444 mov edi, dword ptr {esp+44}–;edi=our fake serial
:004ADAA 85FF test edi, edi
:004ADAC 0F4A7010000 je 0042AF59—-;die if empty
:004ADB2 8B6C2440 mov ebp, dword ptr {esp+40}–ebp=our name
:0042ADB6 85ED test ebp, ebp
:004ADB8 0F849B010000 je 0042AF59—;die if empty
:004ADBE 8A07 mov al, byte ptr {edi}–;compare 1st byte of serial with ‘p’, die
:0042ADC0 3C50 cmp al, 50—-;
:0042ADC2 0F8587010000 jne 0042AF4F—-;if not equal
:0042ADC8 807F0134 cmp byte ptr {edi+01}, 34–:compare byte of serial with ‘4’
:004ADCC 750C jne 0042ADDA—-;
:0042ADCE C70500C8430000000000 mov dword ptr {0043C800}, 00000000
:0042ADD8 EB1C jmp 0042ADF6
As we can see by the above, the code tells us that the first value of our serial will
be ‘p’ and a cycle of a four byte algorythm. I could go on and on about all of the internals
of all this stuff but that would be going beyond the scope of this tutorial. The idea was to show
how to crack this pro, and thats what I’m going to do. Based on the information I’ve given you, and the
information that you can deduce from reading the code, I’ve written a small key generator in C.
If you know C, then you’ll be able to tell where i got the algorythms to write it. So here it is:
#include
#include
int main(void)
{
long code=555583,count1,count2;
char name[25],cod[5],type=’0′;
clrscr();
textcolor(14);
printf(“This is a simple key-generator written by k33t of CYBNET Security Group”);
printf(“=================================================”);
text color(10);
printf(“SubmitWolf(demo)ver4.1 cracked by k33t”);
textcolor(14);
printf(“%c%c%c”,0x10,0x10,0x10″);
textcolor(12);
printf(“Yup”)
prinf(“-November 2002”);
prinf(“‘\n\nSelect Edition PRO(0) or Enterprise(1) (0/1)=”);
scanf(“%c”,&type);
if(type==’1′)code=557283;
getchar();
prinf(“Enter Registration Name=”);
scanf(“%[^\n]”,name);
for(count1=0;count1<=3;count1++
cod[count1]=name[count1];
for(count=1;count1=3;count1++){
for(count2=0;count2<=3;count2++)
cod[count2]=cod[count2]*(code%100);
code=code/100;
}
for(count1=0;name[count1]>0;count1++);
for(count2=0;count2<=3;count2++)
cod[count2]=cod[count2]^(name[count1]+3);
for=(count1-3;count1>=0;count1–){
code=code+(cod[count1]&0xFF);
if(count1>0)
code=code*0x100;
}
if(code<0)code=-code;
for(;code<10000;) code=”code*10;for(;code>999999;) code=code/10;
printf(Your Serial Number=P%c4-%ld”,(type==’1′)? ‘E’:’4’code);
return ;
}
Ok! So! An overall conclusion of this code is:
1.First two characters of the serial must be either ‘PE’ or ‘P4’.
2.Multiply every first four characters or our name with every byte of our serial before ‘-‘
3.XOR every four byte with every byte of our name.
4.Convert to positive number if<0.
5.Convert to number between 10000 and 1000000.
Forgive me if this code is buggy as I wrote it very quickly in the little spare time I had.

HOW TO ADD TWITTER TO ORKUT

Twitter and Orkut have attracted millions of people in the world into social networking. To each, its own. Now is the time to join them so that you can display your Twitter in orkut profile too. It was much awaited as Twitter is already configurable withFacebook, Myspace and other notable social media networks.


To have that you need to install an application named Twitkut. From the right pane , select installTwitkut . Now you can enter your twitter User name in the settings tab .

Scope of Improvement

The only disadvantage with Twitkut Orkut application is that it will not display the tweets automatically .Your Twitter time line will only be updated when you visit your Orkut profile or application page .
It would be better if this app adds a facility to display Twitter tweets along with normal Orkut updates which is usually accessible to all the the friends in the network.
Again, only recently there is been an issue with this app which isn’t accepting Twitter ids.
I hope they solve it as soon as possible and add some extra features because I have used this app and its pretty cool. Use it and post me with updates if you like the idea.

Network hacking


Network Hacking is generally means gathering information about domain by using tools like Telnet, NslookUp, Ping, Tracert, Netstat, etc.
It also includes OS Fingerprinting, Port Scaning and Port Surfing using various tools.

ping Ping is part of ICMP (Internet Control Message Protocol) which is used to troubleshoot TCP/IP networks. So, Ping is basically a command that allows you to check whether the host is alive or not.
To ping a particular host the syntax is (at command prompt)–

c:/>ping hostname.com

example:- c:/>ping http://www.google.com

Various attributes used with ‘Ping’ command and their usage can be viewed by just typing c:/>pingat the command prompt.

Netstat :- It displays protocol statistics and current TCP/IP network connections. i.e. local address, remote address, port number, etc.
It’s syntax is (at command prompt)–

c:/>netstat -n

Telnet :- Telnet is a program which runs on TCP/IP. Using it we can connect to the remote computer on particular port. When connected it grabs the daemon running on that port.
The basic syntax of Telnet is (at command prompt)–

c:/>telnet hostname.com

By default telnet connects to port 23 of remote computer.
So, the complete syntax is-

c:/>telnet http://www.hostname.com port

example:- c:/>telnet http://www.yahoo.com 21 or c:/>telnet 192.168.0.5 21

Tracert :- It is used to trace out the route taken by the certain information i.e. data packets fromsource to destination.
It’s syntax is (at command prompt)–

example:- c:/>tracert http://www.insecure.in

Here “* * * Request timed out.” indicates that firewall installed on that system block the request and hence we can’t obtain it’s IP address.

various attributes used with tracert command and their usage can be viewed by just typingc:/>tracert at the command prompt.

The information obtained by using tracert command can be further used to find out exact operating system running on target system.

Rapidshare hack no waiting


There are two hacks to beat Rapidshare download limits and waiting time.

1) Rapidshare Hack (For Firefox Users) :-
The hot new Firefox plug-in takes browser customization to a whole new level by letting users filter site content or change page behaviors.
The glory of open-source software is that it allows anyone with the inclination and the scripting knowledge to get under the hood and hot-rod their computing environment.
But most of the time, that advantage is available only to people with the programming skills to make the changes they want.

That’s where Greasemonkey, a free plug-in for Firefox, comes in — it simplifies hacking the browser.

Released at the end 2004, Greasemonkey is the latest in a growing arsenal of Firefox customization tools.
It changes how Web pages look and act by altering the rendering process.

http://greasemonkey.mozdev.org/
1) Install the Greasemonkey extension>>
http://downloads.mozdev.org/greasemonkey/greasemonkey_0.2.6.xpi
2) Restart Firefox
3) Go to http://rapidshare.de/files/1034529/rapidshare.user.js.html
4) Right click on rapidshare.user.js and choose “Install User Script“.
5) Run FireFox.
6) From ‘File’ Menu click on Open File then browse to whereever you saved the ‘greasemonkey.xpi’ plug-in.
Open it, wait a couple seconds for the install button becomes active.
7) Click on it to install this plug-in then CLOSE FIREFOX.
8) Run FireFox again.
From the File Menu click on Open File then browse to whereever you saved the ‘rapidshare.user.js’.
9) Open it.
10) Click the Tools Menu then click on Install User Script then click OK.
11) Close FireFox.

The script will let you enjoy “no wait” and multiple file downloads……!

2) Rapidshare Hack (NIC Tricks and MAC Cloning) :-
Rapidshare traces the users IP address to limit each user to a certain amount of downloading per day.
To get around this, you need to show the rapidshare server a different IP address.
Here are some methods for doing this-

A] Short-Out the JavaScript:
1) Goto the page you want to download
2) Select FREE button
3) In the address bar put this- javascript:alert(c=0)
4) Click OK
5) Click OK to the pop-up box
6) Enter the captcha
7) Download Your File

B] Request a new IP address from your ISP server:
Here’s how to do it in windows:
1) Click Start
2) Click run
3) In the run box type cmd.exe and click OK
4) When the command prompt opens type the following. ENTER after each new line.
ipconfig /flushdns
ipconfig /release
ipconfig /renew
exit5) Erase your cookies in whatever browser you are using.
6) Try the rapidshare download again.
Frequently you will be assigned a new IP address when this happens.
Sometime you will, sometimes you will not. If you are on a fixed IP address, this method will not work.
If this works for you, you may want to save the above commands into a batch file, and just run it when you need it.

C] Use a proxy with SwitchProxy and Firefox:
1) Download and install Firefox
2) Download and install SwitchProxy
3) Google for free proxies
4) When you hit your download limit, clean your cookies and change your proxy

D] You can use a bookmarklet to stop your wait times:
1) Open IE
2) Right Click On This Link
3) Select Add to Favorites
4) Select Yes to the warning that the bookmark may be unsafe.
5) Name it “RapidShare No Wait”
6) Click on the Links folder (if you want to display it in your IE toolbar)
7) Click OK
8) You may need to close and reopen IE to see it
9) Goto rapidshare and click the bookmarklet when you are forced to wait