Power-Programmierung/CD1.mdf/assemblr/library/sampler0/cipher.asm

Assembly Source File | 1988-06-28 | 8KB | 353 lines

; cipher.asm
;
; A quick low-security file encryption program, useful for deterring
; casual snoopers.  Execution speed (8 MHz 80286, ST225 disk) is about
; 22000 bytes/sec.
;
; Assembly:
;
; C>masm cipher;
; C>link cipher;
; C>exe2bin cipher.exe cipher.com
; C>erase cipher.exe
;
; Usage:
;
; C>cipher filename.ext
;
; Drive and path names are allowed.  Wildcards are not allowed.
; The file name must be specified completely; there is no default
; extension.  The name of the file is not changed to indicate its
; plain or enciphered status.
;
; The file is enciphered in place.  NO BACKUP COPY IS MADE.  The
; easiest way to make a backup copy is to use CIPHER in a batch file
; with a COPY command, although this source code could also be
; modified to make a backup.
;
; The key is found in the environment strings, under KEYWORD.
; It can be set with the SET command:
;
; C>set KEYWORD=Mandarin_Orange
;
; It can be verified with the SET command:
;
; C>set
;
; This will produce a listing of the environment strings:
;
; COMSPEC=C:\COMMAND.COM
; PATH=D:\;C:\PCDOS330;C:\BINARY
; PROMPT=$t$h$h$h $n$g
; KEYWORD=Mandarin_Orange
;
; It can be cleared by rebooting or with the SET command:
;
; C>set KEYWORD=
;

DEBUG        equ    0
BLOCKSIZE    equ    1024
PRNG_A        equ    17257        ; Shippensburg, Pennsylvania
PRNG_C        equ    21545        ; Mount Savage, Maryland

codeseg        segment    para public 'code'
        assume cs:codeseg,ds:codeseg,ss:codeseg,es:codeseg

        org    0081h
cmd_line    label    byte

        org    0100h
cipher        proc    near

        push    cs
        pop    ds        ; ds = cs

        mov    ah,30h        ; get DOS version number
        int    21h
        cmp    al,2
        jge    look_for_keyword

        mov    dx,offset dos_ver_msg
        jmp    general_exit

; search the DOS environment for "KEYWORD=something"
; and use "something" to seed the random generator

look_for_keyword:
        mov    ax,ds:2ch    ; get environment segment from PSP
        mov    es,ax        ; copy it to ES
        xor    si,si        ; start at offset = 0

env_test_line:
        mov    al,es:[si+1]    ; peek at the next environment byte
        cmp    al,0        ; is it a null?
        je    key_error    ; yes: we ran out of environment

        xor    bx,bx        ; clear the match counter
        mov    di,offset key_marker ; point at key_marker

env_test_byte:
        mov    al,es:[si]    ; get byte from environment
        inc    si        ; point to next environment byte
        mov    ah,[di]        ; get byte from key_marker
        inc    di        ; point to next key_marker byte
        cmp    al,ah        ; compare env byte to key_marker byte
        jne    env_skip_line    ; jump on mismatch

        inc    bx        ; increment match counter
        cmp    bx,marker_len    ; do we have enough matches?
        je    env_skip_equals    ; yes: jump

        jmp short env_test_byte    ; no:  keep looking

key_error:
        mov    dx,offset keyword_msg
        jmp    general_exit

; here the current environment string is not KEYWORD
; skip to the beginning of the next line

env_skip_line:
        mov    al,es:[si]    ; get byte from environment
        inc    si        ; point to next environment byte
        cmp    al,0        ; is it a null?
        jne    env_skip_line    ; repeat until a null is found

        jmp short env_test_line    ; and then go test the next line

; here es:si points to the first byte after the keyword marker
; scan past the '=' in the environment string

env_skip_equals:
        mov    al,es:[si]    ; get byte from environment
        inc    si        ; point to next environment byte
        cmp    al,0        ; end of string?
        je    key_error

        cmp    al,'='        ; find '='
        jne    env_skip_equals

; here es:si points to the first byte after '='

env_skip_blanks:
        mov    al,es:[si]    ; get byte from environment
        inc    si        ; point to next environment byte
        cmp    al,0        ; end of string?
        je    key_error

        cmp    al,20h        ; skip over controls and spaces
        jle    env_skip_blanks

if DEBUG
        push    ax
        push    dx
        mov    ah,9        ; display string
        mov    dx,offset key_equ_msg
        int    21h
        pop    dx
        pop    ax
endif

; here es:si points to the second byte of the key string

        dec    si        ; point to first string byte
        mov    seed,0        ; clear accumulator
make_seed_loop:
        mov    al,es:[si]    ; get byte from environment
        inc    si        ; point to next environment byte

        cmp    al,20h        ; exit on null or control or space
        jle    read_filename

        cmp    al,7fh        ; exit on first graphic byte
        jg    read_filename

if DEBUG
        push    ax
        push    dx
        mov    ah,2        ; display character
        mov    dl,al
        int    21h
        pop    dx
        pop    ax
endif

        xor    ah,ah        ; clear high input byte
        shl    seed,1
        shl    seed,1
        shl    seed,1
        add    seed,ax        ; accumulator += new byte

        jmp short make_seed_loop

name_error:
        mov    dx,offset name_msg
        jmp    general_exit

; now get the filename from the command line

read_filename:
        push    cs
        pop    es        ; es = cs

if DEBUG
        push    ax
        push    dx
        mov    ah,9        ; display string
        mov    dx,offset key_end_msg
        int    21h
        pop    dx
        pop    ax
endif

        mov    si,offset cmd_line
skip_blanks:
        lodsb            ; read a byte from command line
        cmp    al,0dh        ; check for end of line
        je    name_error

        cmp    al,20h        ; check for blanks or controls
        jle    skip_blanks

; here si points to the second byte of the filename

        dec    si        ; si = filename address
        push    si        ; save filename address
skip_filename:
        lodsb            ; read a byte from command line
        cmp    al,20h        ; exit on null or control or space
        jg    skip_filename

; here si points to the second byte after the filename

        dec    si        ; point to first control or space
        mov    byte ptr [si],0    ; change it to a null

; now the filename has been found and terminated
; call DOS to open the file

        mov    ax,3d02h    ; open file for read/write
        pop    dx        ; dx = filename address
        int    21h
        mov    handle,ax    ; store file handle
        jnc    outer_loop    ; carry flag indicates error

        mov    dx,offset open_msg
        jmp    general_exit

outer_loop:
        mov    ah,2        ; display dot on stdout
        mov    dl,'.'
        int    21h

        mov    ah,3fh        ; read a block from the file
        mov    bx,handle
        mov    cx,BLOCKSIZE
        mov    dx,offset buffer
        int    21h
        jc    read_error

        cmp    ax,0        ; if the byte count was zero,
        je    close_and_quit    ; then the file block was empty

        mov    byte_count,ax    ; save byte count

        mov    cx,ax        ; initialize inner loop count
        mov    si,offset buffer ; si = data address
        mov    di,si        ; di = data address
        mov    bx,PRNG_A    ; bx = multiplier
inner_loop:
        mov    ax,seed
        mul    bx
        add    ax,PRNG_C
        mov    seed,ax        ; use ah for key byte

        lodsb            ; get a data byte
        xor    al,ah        ; convert the data byte
        stosb            ; store the data byte

        loop    inner_loop    ; repeat as necessary

        mov    ax,4200h    ; rewind to beginning of block
        mov    bx,handle
        mov    cx,ptr_msw
        mov    dx,ptr_lsw
        int    21h
        jc    seek_error

        mov    ah,40h        ; write block back to file
        mov    bx,handle
        mov    cx,byte_count
        mov    dx,offset buffer
        int    21h
        jc    write_error

        mov    cx,byte_count    ; check for write errors
        cmp    ax,cx
        jne    write_error

        cmp    ax,BLOCKSIZE    ; if the block was not full,
        jne    close_and_quit    ; then we're done

        add    ptr_lsw,BLOCKSIZE ; find new file position
        adc    ptr_msw,0

        jmp    outer_loop    ; go back for the next block

write_error:
        mov    dx,offset write_msg
        jmp short general_exit

read_error:
        mov    dx,offset read_msg
        jmp short general_exit

seek_error:
        mov    dx,offset seek_msg
        jmp short general_exit

close_and_quit:
        mov    ah,3eh        ; close file
        mov    bx,handle
        int    21h

        mov    dx,offset done_msg

general_exit:
        mov    ah,9        ; display string
        int    21h

        int    20h        ; return to DOS

cipher        endp

key_marker    db    'KEYWORD'
marker_len    equ    $-key_marker

done_msg    db    'Done$'
name_msg    db    'Filename error$'
open_msg    db    'Open error$'
read_msg    db    'Read error$'
seek_msg    db    'Seek error$'
write_msg    db    'Write error$'
keyword_msg    db    'Keyword error$'
dos_ver_msg    db    'Requires DOS 2.00+$'

if DEBUG
key_equ_msg    db    'DEBUG: Key = "$'
key_end_msg    db    '"',0dh,0ah,'$'
endif

ptr_msw        dw    0
ptr_lsw        dw    0
handle        dw    0
seed        dw    0
byte_count    dw    0
buffer        label    byte    ; this goes last!

codeseg        ends
        end    cipher