32位汇编语言学习笔记(43)-- 生成随机数



此程序出自《Assembly Language step by step programming with linux》第12章，用于演示随机数函数的使用，共涉及两个随机数函数：
void srand( unsigned int seed ); //设置随机数种子
int rand( void ); //获取随机数

先看程序：

[SECTION .data]			; Section containing initialised data

Pulls	   dd 36		;  How many numbers do we pull?
Display    db 10,'Here is an array of %d %d-bit random numbners:',10,0
ShowArray  db '%10d %10d %10d %10d %10d %10d',10,0		
CharTbl db '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-@'

[SECTION .bss]		; Section containing uninitialized data

BUFSIZE  equ 70		; # of randomly chosen chars
RandVal  resd 1		; Reserve an integer variable
Stash    resd 72	; Reserve an array of 72 integers for randoms
RandChar resb BUFSIZE+5	; Buffer for storing randomly chosen characters

[SECTION .text]		; Section containing code

extern printf	
extern puts
extern rand
extern scanf	
extern srand
extern time			
		
pull31: mov ecx,0		; For 31 bit random, we don't shift
	jmp pull
pull16: mov ecx,15		; For 16 bit random, shift by 15 bits
	jmp pull
pull8:	mov ecx,23		; For 8 bit random, shift by 23 bits
	jmp pull
pull7:  mov ecx,24		; For 7 bit random, shift by 24 bits
	jmp pull
pull6:	mov ecx,25		; For 6 bit random, shift by 25 bits
	jmp pull
pull4:	mov ecx,27		; For 4 bit random, shift by 27 bits
pull:	push ecx		; rand trashes ecx; save shift value on stack
	call rand		; Call rand for random value; returned in EAX
	pop ecx			; Pop stashed shift value back into ECX
	shr eax,cl		; Shift the random value by the chosen factor
				;  keeping in mind that part we want is in CL
	ret			; Go home with random number in EAX

newline:
	mov ecx,10	; We need a skip value, which is 10 minus the
	sub ecx,eax	;  number of newlines the caller wants.
	add ecx,nl	; This skip value is added to the address of
	push ecx	;  the newline buffer nl before calling printf.
	call printf	; Display the selected number of newlines
	add esp,4	; Stack cleanup for one parm
	ret		; Go home
nl	db 10,10,10,10,10,10,10,10,10,10,0
	
shownums:	
	mov esi, dword [Pulls]	; Put pull count into ESI
.dorow:	mov edi,6		; Put row element counter into EDI
.pushr:	dec edi			; Decrement row element counter
	dec esi			; Decrement pulls counter
	push dword [Stash+esi*4]; Push number from array onto stack
	cmp edi,0		; Have we filled the row yet?
	jne .pushr		; If not, go push another one
	push ShowArray		; Push address of base display string
	call printf		; Display the random numbers
	add esp,28		; Stack cleanup: 7 items X 4 bytes = 28
	cmp esi,0		; See if pull count has gone to 0
	jnz .dorow		; If not, we go back and do another row!
	ret			; Done, so go home!
	
puller:
	mov esi,dword [Pulls]	; Put pull count into ESI
.grab:	dec esi			; Decrement counter in ESI
	call edi		; Pull the value; it's returned in eax
	mov [Stash+esi*4],eax   ; Store random value in the array
	cmp esi,0		; See if we've pulled 4 yet
	jne .grab		; Do another if ESI <> 0 
	ret			; Otherwise, go home!
	
%macro GenAndShowNBitRandom 2  
    mov edi, %1	; Copy address of random # subroutine into edi
	call puller	; Pull as many numbers as called for in [pulls]				
	push %2		; Size of numbers being pulled, in bits
	push dword [Pulls] ; Number of random numbers generated
	push Display	; Address of base display string
	call printf	; Display the label
	add esp,12	; Stack cleanup: 3 parms X 4 bytes = 12
	call shownums	; Display the rows of random numbers
%endmacro  

; MAIN PROGRAM:
					
global main			; Required so linker can find entry point
	
main:
    push ebp		; Set up stack frame for debugger
	mov ebp,esp
	push ebx		; Program must preserve EBP, EBX, ESI, & EDI
	push esi
	push edi
;;; Everything before this is boilerplate; use it for all ordinary apps!	

; Begin by seeding the random number generator with a time_t value:	
Seedit:	push 0		; Push a 32-bit null pointer to stack
	call time	; Returns time_t value (32-bit integer) in EAX
	add esp,4	; Stack cleanup for one parm
	push eax	; Push time_t value in EAX onto stack
	call srand	; Time_t value is the seed value for random # gen
	add esp,4	; Stack cleanup for one parm

; All of the following code blocks are identical except for the size of
; the random value being generated:
	
; Create and display an array of 31-bit random values
    GenAndShowNBitRandom pull31,32
	
; Create and display an array of 16-bit random values
    GenAndShowNBitRandom pull16,16
	
; Create and display an array of 8-bit random values:
    GenAndShowNBitRandom pull8,8

; Create and display an array of 7-bit random values:
    GenAndShowNBitRandom pull7,7

; Create and display an array of 4-bit random values:
    GenAndShowNBitRandom pull4,4

; Clear a buffer to nulls:
Bufclr:	mov ecx, BUFSIZE+5  ; Fill whole buffer plus 5 for safety
.loop:	dec ecx		    ; BUFSIZE is 1-based so decrement first!
	mov byte [RandChar+ecx],0     ; Mov null into the buffer
	cmp ecx,0	    ; Are we done yet?
	jnz .loop	    ; If not, go back and stuff another null

; Create a string of random alphanumeric characters:
Pulchr:	mov ebx, BUFSIZE	; BUFSIZE tells us how many chars to pull
.loop:	dec ebx			; BUFSIZE is 1-based, so decrement first!
	mov edi,pull6		; For random in the range 0-63
	call puller		; Go get a random number from 0-63
	mov cl,[CharTbl+eax]	; Use random # in eax as offset into table
	                        ;  and copy character from table into CL
	mov [RandChar+ebx],cl	; Copy char from CL to character buffer
	cmp ebx,0		; Are we done having fun yet?
	jne .loop		; If not, go back and pull another

; Display the string of random characters:
	mov eax,1	; Output a newline
	call newline	;  using the newline procedure
	push RandChar	; Push the address of the char buffer 
	call puts	; Call puts to display it
	add esp,4	; Stack cleanup for one parm
	mov eax,1	; Output a newline
	call newline	;  using the newline subroutine
		
;;; Everything after this is boilerplate; use it for all ordinary apps!
	pop edi		; Restore saved registers
	pop esi
	pop ebx
	mov esp,ebp	; Destroy stack frame before returning
	pop ebp
	ret		; Return control to Linux

程序分析：
pull函数，这个函数有些奇怪，有很多入口，主要用于设置ecx值，最终会跳转到pull。ecx用于控制右移的位数。函数最终目的是生成有位数限制的随机数。
pull31: mov ecx,0  //随机数是31位，不右移
 jmp pull
pull16: mov ecx,15  //16位随机数，右移15位
 jmp pull
pull8: mov ecx,23  //8位随机数，右移23位
 jmp pull
pull7:  mov ecx,24  //7位随机数，右移24位
 jmp pull
pull6: mov ecx,25  //6位随机数，右移25位
 jmp pull
pull4: mov ecx,27  //4位随机数，右移27位
pull: push ecx  //保存ecx值
 call rand  //调用rand函数，生成伪随机数
 pop ecx     //恢复ecx值
 shr eax,cl  //返回的随机数值右移cl位
 ret   

newline函数，用于打印0-10个空行，空行个数由eax来控制。
newline:
 mov ecx,10 //ecx=10
 sub ecx,eax //ecx = ecx -eax
 add ecx,nl //ecx=nl+ecx，nl是一个字节数组的首地址，保存10个换行符
 push ecx //保存格式化字符串作为入参
 call printf //调用printf函数 
 add esp,4  //清理调用栈
 ret  
nl db 10,10,10,10,10,10,10,10,10,10,0

shownums函数用于打印Stash数组中的随机数。
shownums: 
 mov esi, dword [Pulls] //esi=36
.dorow: mov edi,6  //edi=6
.pushr: dec edi   //edi=edi-1
 dec esi   //esi = esi -1
 push dword [Stash+esi*4]//把数组元素压入栈，用于作为printf的入参
 cmp edi,0  //edi和0比较
 jne .pushr  //如果不等于0，跳转到.pushr
 push ShowArray  //格式化字符串压入栈
 call printf  //调用printf显示随机数
 add esp,28  //清理栈（7个参数）
 cmp esi,0  比较esi和0
 jnz .dorow  //如果不等于0，跳转到.dorow，显示接下来六个随机数
 ret   

puller用于生成随机数，并把结果保存到Stash数组中
puller:
 mov esi,dword [Pulls] //esi = 36
.grab: dec esi   //esi = esi -1
 call edi  //此时edi应该装载的是pull函数的几个入口地址之一，call edi会调用pull函数
 mov [Stash+esi*4],eax   //保存随机数到Stash[4*esi]数组中
 cmp esi,0  //比较esi和0
 jne .grab     //如果esi不等于0， 跳转，继续循环。
 ret   

GenAndShowNBitRandom宏，用于生成规定位数的随机数，并打印出显示信息，宏的第一个参数是pull函数的跳转地址，第二个参数是随机数的位数。
%macro GenAndShowNBitRandom 2 
    mov edi, %1 //edi=pull函数跳转地址，例如pull31
 call puller //调用puller函数，生成随机数
 push %2  //printf函数的最右一个参数：随机数的位数
 push dword [Pulls]  //随机数个数
 push Display //格式化字符串地址
 call printf //调用printf函数，打印随机数概要信息
 add esp,12 //清理栈，3个参数
 call shownums //打印随机数信息。
%endmacro 

主程序：
Seedit: push 0  //timer=0
 call time //调用time函数，获取当前时间
 add esp,4  //清理栈
 push eax  //time_t值作为srand函数入参
 call srand  //调用srand函数，设置随机数种子
 add esp,4  //清理栈

    GenAndShowNBitRandom pull31,32  //生成并打印32位随机数
    GenAndShowNBitRandom pull16,16 //生成并打印16位随机数
    GenAndShowNBitRandom pull8,8 //生成并打印8位随机数
    GenAndShowNBitRandom pull7,7 //生成并打印7位随机数
    GenAndShowNBitRandom pull4,4  //生成并打印4位随机数

Bufclr: mov ecx, BUFSIZE+5  //ecx= BUFSIZE+5
.loop: dec ecx      //ecx=ecx-1
 mov byte [RandChar+ecx],0     // RandChar[ecx]=0
 cmp ecx,0     //比较ecx和0
 jnz .loop     //如果ecx不等于0，继续循环

Pulchr: mov ebx, BUFSIZE //ebx= BUFSIZE
.loop: dec ebx   //ebx= BUFSIZE-1
 mov edi,pull6  //edi=pull6，用于生成六位随机数
 call puller  //调用puller函数，生成六位随机数（0-63）
 mov cl,[CharTbl+eax] //cl = CharTbl[eax]，使用随机数作为索引获取字母表中的字母，保存到cl中。
 mov [RandChar+ebx],cl // RandChar[ebx]=cl
 cmp ebx,0 //ebx和0比较
 jne .loop  //不等于0继续循环，共循环BUFSIZE次。

 mov eax,1 //eax=1，要求打印一个换行符
 call newline //调用newline函数，打印一个换行符
 push RandChar //需要打印的RandChar字符串
 call puts //调用puts函数进行打印
 add esp,4  //清理栈
 mov eax,1 //eax=1，要求打印一个换行符
 call newline //调用newline函数，打印一个换行符

makefile文件内容：

randtest: randtest.o
	gcc randtest.o -o randtest
randtest.o: randtest.asm
	nasm -f elf -F stabs randtest.asm

测试：

[root@bogon randtest]# make
nasm -f elf -F stabs randtest.asm
gcc randtest.o -o randtest
[root@bogon randtest]# ./randtest 

Here is an array of 36 32-bit random numbners:
 783082802 2015556527  543193849 2039226355  941006786   31398675
1774612191 1481082542  470873846  116734738   14801476  962009402
 288935524  784925144 2104709381 1237311754  601393386 1134661054
1752141735  528512928  848300003  858978037 1617820568  623786287
 291301057 1585022978   84190193 1438304756 1614336276  950412687
1100380723   12131855  632155963 1232307843 1616421653  740413255

Here is an array of 36 16-bit random numbners:
     13695      44098      46752      34032      29728      43189
     56002      11884       7596      32048      13189      35372
     55967      56808      42628      39838      30920      16414
     22532      22846       8920      39697      20276      30563
      6695      64733      55417       6325      45441      17810
     14986      23603      57495      36424      42387      23462

Here is an array of 36 8-bit random numbners:
       156          4        147        110        230         22
       243        234          9         21         68        110
       155        132        127         66         98        228
        73        162        240         77        202        215
        75        223        152        239        254         10
        54        136         65         50        245        211

Here is an array of 36 7-bit random numbners:
        50          0        121         61        123        110
        38         49         20         99        114        115
        92         21          8         11         29         98
        75        103         37         92         26         45
        10        113        100         70         80         75
         6         89         60          5         95        127

Here is an array of 36 4-bit random numbners:
         5         12         10         15          9         13
        11          9          0          8          8         15
        11          3          7         15         15         12
         4          9          9          6         13          1
        11          1         11          0          9         11
         0          9         11          4         15         12

@G8iqJJt12Oh8FKKEINTmIvq6ag7RXTAU5TkF9xJ3GaZBkMPiRU7jzFMxKmfhqhySz9Xt7