markin32.asm

破解很多程序的序列号算法程序

; Markin32 v1.3 Key Generator.
; By CrackZ (04/09/98).
;
; Use tasm /zi markin32.asm and then tlink /v markin32
; to generate markin32.exe

.MODEL SMALL
.STACK 100h
.386

.DATA

input   DB 25h,0
serial  DB 50h dup ('$')                      
prompt  DB 'Input your Registration Name (max 30 chars): ','$'
done    DB 'Your Registration Code is: ','$'
lf      DB 0ah,0dh,'$'
logo    DB 0ah,0dh, '-------------------------------',0ah,0dh
	DB          '  Markin32 v1.3 Key Generator  ',0ah,0dh
        DB          '     by CrackZ                 ',0ah,0dh
	DB          '-------------------------------',0ah,0dh
	DB 0ah,0dh,'$'
        
.CODE

START:
	MOV	AX,@DATA
	MOV	DS,AX
	MOV	ES,AX
	LEA	EDX,[logo]
	MOV	AH,09h
	INT	21h				;Display Logo.
	LEA	EDX,[prompt]
	MOV	AH,09h
	INT	21h				;Prompt.
	LEA	EDX,[input]		 
	MOV	AH,0Ah
	INT	21h				;Get registration name.
	LEA	EDX,[lf]
	MOV	AH,09h
	INT	21h                     	;Linefeed for aesthetics.

	CMP	BYTE PTR [input+1],00		;Check_name_was_entered.
	JZ	endprg

	LEA	EDI,input+2			;Name in EDI.
	MOVZX	EBX, BYTE PTR [EDI-01]		;Get length of name in EBX.	
	XOR	EAX,EAX
	XOR	ESI,ESI
	XOR	ECX,ECX				;Clear some registers.
	CMP	EBX, 00000008h			;Check name for exactly 8.
	JL	less8				;Jump less than 8.
	JGE	abovst				;Jump above 8.

less8:
	XOR	EDX,EDX
	MOV	ECX,08h
	MOV	EDX,ECX
	SUB	ECX,EBX				;Sub actual length from 8 (ECX holds remainder).
	JMP	check				;Now check for spaces and numbers.

check:
	MOV	AL,BYTE PTR [EDI]
	CMP	AL,20h				;Check for space.
	JZ	addanx				;Jump if space.
	CMP	AL,30h				;Check below 0.
	JB	itsok
	CMP	AL,39h				;Check above 9.
	JA	itsok
	JMP	addanx			

itsok:
	MOV	[ESI],AL			;Store in ESI.
	JG	shift
	JMP	endprg

shift:	
	DEC	EBX				;Decrement actual length.
	TEST	EBX,EBX				;Done all name characters?.
	JZ	makeit8
	INC	ESI				;Store.
	INC	EDI				;Next name character.
	JMP	check				;Loop again.

addanx:
	XOR	AL,AL
	MOV	AL,78h				;'x'.
	MOV	[ESI],AL			;Add the 'x'.
	CALL	shift	
	JMP	check				;Loop.
	
;ECX holds the number of 'x' 's that need to be added.

makeit8:
	INC	ESI				;Store
	XOR	AL,AL				;Clear AL.
	MOV	AL,78h				;'x'
	MOV	[ESI],AL
	DEC	ECX				;Decrement remainder.
	TEST	ECX,ECX				;8 done.
	JNZ	makeit8				;Loop
	SUB	ESI,07h				;Fix up ESI.
	JMP	reverse

;This section deals with names which are 8 in length or greater.
;Note that the program handles names greater than 8 with space and numeric characters
;differently.

abovst:
	XOR	EDX,EDX
	XOR	ECX,ECX
	MOV	ECX,08h				;Loop count.

above8:
	MOV	AL,BYTE PTR [EDI]		;Name.
	CMP	AL,20h
	JZ	nchar				;Get the next char.
	CMP	AL,30h
	JB	itsok2
	CMP	AL,39h
	JA	itsok2
	JMP	nchar

nchar:
	INC	EDI				;Next char in name.
	DEC	EBX				;Name length.
	TEST	EBX,EBX

;If EBX gets to 0 and we still haven't done 8 characters then x's need to be added.
;Subtracting EDX from 8 will give the number of x's to add (in ECX).

	JNZ	above8
	MOV	ECX,08h
	SUB	ECX,EDX
	XOR	AL,AL
	MOV	AL,78h
	JMP	addx2	

addx2:
	MOV	[ESI],AL
	DEC	ECX
	INC	ESI
	TEST	ECX,ECX
	JNZ	addx2
	SUB	ESI,08h				;Fixup.
	JMP	reverse

itsok2:
	MOV	[ESI],AL			;Store in ESI. 
	DEC	EBX
	DEC	ECX				;Loop.
	INC	EDX				;EDX counts chars done that != 20h or numbers.
	INC	EDI
	INC	ESI				;Shift EDI,ESI.
	TEST	ECX,ECX
	JNZ	above8				;Jump more name needed.
	SUB	ESI,08h
	JMP	reverse

;Now we have the fixed up the name in EDI, lets reverse it.

reverse:
	MOV	EDI,ESI				;Copy name to EDI.
	XOR	ECX,ECX
	XOR	EBX,EBX
	XOR	EAX,EAX				;Clear registers.
	MOV	EBX,07h
	ADD	ECX,40h				;Move ECX somewhere convenient.

rev:
	MOV	AL,BYTE PTR [EDI+EBX]
	MOV	[ECX],AL			;Store at ECX's new location.
	DEC	EBX
	INC	ECX
	CMP	EBX,-01h			;Done 8 characters.
	JNZ	rev				
	SUB	ECX,08h				;Correct ECX.

;Now our name has been fixed and is reversed starting at ECX. The key generator 
;can now perform the calculation.

	XOR	ESI,ESI
	XOR	EDI,EDI
	XOR	EBX,EBX	
	XOR	EDX,EDX
	XOR	EAX,EAX				;Clear registers for calculation.	

calc:	
	MOV	DL,[ECX]			;Reversed name.
	ADD	DL,BL
	MOV	AL,DL
	INC	ESI				;Loop.
	ADD	AL,06h
	JMP	calc2

calc2:
	CMP	EAX,5Ah				;'Z' - Uppercase.
	JLE	alpha	
	CMP	EAX,61h				;'a' - Lowercase.
	JGE	alpha	
	ADD	AL,0Ch
	JMP	alpha

alpha:
	CMP	EAX,7Ah				;'z'.
	JLE	func
	INC	EDI
	SUB	AL,0Ch
	MOV	[EDI],AL
	JMP	func2

func:
	INC	EDI				;Increment store location.
	MOV	[EDI],AL			;EDI used to store new code.
	JMP	func2

func2:
	INC	ECX				;Next letter.
	INC	BL
	CMP	ESI,08h	
	JNZ	calc
	SUB	EDI,07h				;Fix up EDI.
	JMP	final				;Correct 8 character code is now calculated.

;Now we'll uppercase our result and prepare it for output.

final:
	XOR	ECX,ECX				;Clear ECX for loop.
	XOR	EBX,EBX				;Clear EBX now for output.

tstcase:	
	MOV	AL,BYTE PTR [EDI]
	CMP	AL,61h				;Below 'a'.
	JB	upcase
	SUB	AL,20h				;Upper case
	MOV	[EDI],AL			;Store.
	JMP	upcase 

upcase:
	INC	EDI
	INC	ECX
	CMP	ECX,08h
	JNZ	tstcase
	SUB	EDI,08h				;Another fix up.
	XOR	EAX,EAX				;Clear EAX.
	ADD	EBX,40h
	MOV	EAX,0Eh				;14 decimal.
	XOR	ECX,ECX

;This next loop adds 14 'x' characters at [EBX].

memx:
	MOV	CL,078h
	MOV	[EBX],CL
	INC	EBX				;Shift EBX.
	DEC	EAX				;Decrement 14.
	TEST	EAX,EAX				;End of loop.
	JNZ	memx				;Add more 'x'.

;Now to move the good code characters into the right position ready for output.
		
	SUB	EBX,0Eh
	XOR	ECX,ECX
	MOV	CL,[EDI]
	MOV	[EBX+02],CL			;Position 3.
	INC	EDI
	MOV	CL,[EDI]
	MOV	[EBX+03],CL			;Position 4.
	INC	EDI
	MOV	CL,[edi]
	MOV	[EBX+05],CL			;Position 6.
	INC	EDI
	MOV	CL,[EDI]
	MOV	[EBX+06],CL			;Position 7.
	INC	EDI
	MOV	CL,[EDI]
	MOV	[EBX+10],CL			;Position 11.
	INC	EDI
	MOV	CL,[EDI]
	MOV	[EBX+11],CL			;Position 12.
	INC	EDI
	MOV	CL,[EDI]
	MOV	[EBX+12],CL			;Position 13.
	INC	EDI
	MOV	CL,[EDI]
	MOV	[EBX+13],CL			;Position 14.

;Final output.

	XOR	EAX,EAX
	MOV	EAX,0Eh
	MOV	BYTE PTR [EBX+EAX],'$'		;Paste end character to the registration code.
	LEA	EDX,[done]
	MOV	AH,09h
	INT	21h				;"Your Registration Code is".
	LEA	EDX,[EBX]
	MOV	AH,09h
	INT	21h				;Print registration code.

endprg:
	LEA	EDX,[lf]
	MOV	AH,09h
	INT	21h
	MOV	AX,4C00h
	INT	21h
	
END START