Codifica.com

Codifica un archivo, usando otro archivo como clave (esto era un buen sistema en tiempos de los 286, que tenían poca potencia de cálculo, pero no es un buen método criptográfico hoy en día).
Toma dos parámetros, que son los archivos:
<code>Codifica archivo_en_texto_claro archivo_clave</code>
o
<code>Codifica archivo_en_clave archivo_clave</code>

Devuelve un archivo llamado Codout que está en texto plano o en clave (si la clave es incorrecta, el archivo estará "doblemente codificado").

Este es un programa para CSEMBL, lo que quiere decir que se usan etiquetas en la forma ":etiqueta" y referencias en la forma "%referencia%".

<code>
:INI
;En cs:5d y cs:6d se meten los dos primeros
;argumentos syss pueden ser archivos.
;asumimos es=cs
pushf
sti
mov si,5d
mov di,%nombarch1%
mov cx,8
:bucl1
    lodsb
    cmp al,20
    STOSB
LOOPNZ %bucl1%
CMP AL,20
JNZ %bucl1fin%
dec di
:bucl1fin
mov by [di],2e
inc di
mov cx,3
mov si,5d+8
:bucl2
    lodsb
    cmp al,20
    STOSB
LOOPNZ %bucl2%
cmp al,20
jnz %bucl2fin%
dec di
:bucl2fin
mov by [di],0
;Aqu¡ no hace falta aumentar DI
mov si,6d
mov di,%nombarch2%
mov cx,8
:bucl3
    lodsb
    cmp al,20
    STOSB
LOOPNZ %bucl3%
cmp al,20
jnz %bucl3fin%
dec di
:bucl3fin
mov by [di],2e
inc di
mov cx,3
mov si,6d+8
:bucl4
    lodsb
    cmp al,20
    STOSB
LOOPNZ %bucl4%
cmp al,20
jnz %bucl4fin%
dec di
:bucl4fin
mov by [di],0
;Aqu¡ no hace falta aumentar DI
POPF
XOR CX,CX
MOV DX,%nombarch1%
MOV AX,100
CALL %OPFIL%
cmp ax,FFFF
jnz %NOERROR_1%
;Error al abrir 1=error al leer 1
JMP %ERROR_L2%
;int 20
:NOERROR_1
MOV DX,%nombarch2%
MOV AX,200
CALL %OPFIL%
cmp ax,FFFF
jnz %NOERROR_2%
;int 20
;Error al abrir 2=error al leer 2
JMP %ERROR_L2%
:NOERROR_2
; Todav¡a no s‚ c¢mo averiguar‚ el tercer
;nombre
MOV DX,%nombarch3%
;Este archivo se abre para escritura
MOV AX,301
CALL %OPFIL%
cmp ax,FFFF
jnz %NOERROR_3%
;Error al abrir 3=error al leer 3
JMP %ERROR_L3%
;int 20
:NOERROR_3
;---------Leer 3c00 bytes del archivo base
:Leer_1
MOV AX,100
MOV CX,3c00
MOV DX,%buffer1%
CALL %RFIL%
;---------Almacenar el valor de salida,
;         a menos que sea -1
CMP AX,FFFF
JNZ %NOERROR_4%
JMP %ERROR_L1%
:NOERROR_4
MOV [%bytes_arch1%],ax
;---------Leer 3c00 bytes del archivo clave
MOV DX,%buffer2%
MOV CX,3c00
:leyendo_2
push cx
MOV AX,200
CALL %RFIL%
add dx,ax
pop cx
CMP AX,FFFF
JNZ %NOERROR_5%
JMP %ERROR_L2%
:NOERROR_5
sub cx,ax
;--------Si se acaba archivo-clave, vuelve
;        a leerlo.
jz %yaleido_2%
;LSEEK #2 to 0:
push cx
push dx
xor bh,bh
mov bl,[2+%handle%]
xor dx,dx
xor cx,cx
mov ax,4200
int 21
pop dx
pop cx
jmp %leyendo_2%
:yaleido_2
; No incluir la siguiente l¡nea podr¡a
; hacer imposible el desciframiento
; de archivos cortos, porque parte de la
; clave podr¡a ser ilegible. 
mov cx,[%bytes_arch1%]
MOV BX,0
:codificar
MOV AX,[BX+%buffer1%]
XOR AX,[BX+%buffer2%]
MOV [BX+%buffer3%],AX
inc bx
loop %codificar%
;-------Escribir salida
MOV CX,[%bytes_arch1%]
:leyendo_3
MOV AX,301
MOV DX,%buffer3%
CALL %RFIL%
CMP AX,FFFF
JNZ %NOERROR_6%
JMP %ERROR_L3%
:NOERROR_6
cmp wo [%bytes_arch1%],3c00
jnz %fin%
JMP %Leer_1%
:FIN
mov ah,9
mov dx,%msg_fin%
int 21
int 20
:ERROR_L1
mov dx,%msg_errl1%
jmp %sherrmsg%
:ERROR_L2
mov dx,%msg_errl2%
jmp %sherrmsg%
:ERROR_L3
mov dx,%msg_errl3%
jmp %sherrmsg%
:sherrmsg
mov al,9
int 21
mov dx,%msg_uso%
mov al,9
int 21
int 20

:msg_fin
db "Archivo codificado" 0a 0d 24
:msg_errl1
db "Error leyendo archivo 1" 0a 0d 24
:msg_errl2
db "Error leyendo archivo 2" 0a 0d 24
:msg_errl3
db "Error escribiendo archivo 3" 0a 0d 24
:msg_uso
db "Uso: CODIFICA arch_ori arch_clave" 0a 0d 0a 0d
db "Crea un archivo que contiene el archivo original codificado" 0a 0d 24
:nombarch1
db "01234567.123" 0 0
:nombarch2
db "01234567.123" 0 0
:nombarch3
db "codout__.$$$" 0 0
:bytes_arch1
dw 0 0

;BIBLIOTECA DE EJECUCIàN CUTRESSEMBLER
;CUTRESSEMBLER RUN-TIME LIBRARY
;
:OPFIL
;PARAMS:
;AH= n£m_archivo
;AL= modo_archivo:
;      0: R.   NO Crear nuevo archivo. 
;      1: W.   Crear si no existe. 
;      2: R/W. Crear si no existe. 
; 
;DS:DX= nombre_archivo (limitado por "00")
 
PUSH BX 
    ;Comprobaci¢n de la validez del primer par metro: N§ Control/Arch. 
    PUSH AX
        ;1: No puede ser "FF". 
        CMP Ah,FF
        JZ %OPF_EEZ0% 
        ;2: No puede ser mayor de 10 (0Ah). 
        CMP Ah,0a
        JG %OPF_EEZ1%
        ;3: No ha de estar en uso. 
        MOV Bx,%HANDLE%
        PUSH AX
            MOV AL,AH
            XOR AH,AH
            ADD BX,AX
        POP AX
        CMP by [BX],ff
        JZ %OPF_EEZ3% 
    POP AX 
    PUSH AX 
        ;Esto evita que C[arry] sea verdad.                
        XOR BX,BX
        MOV AH,3d
        INT 21
        JC %OPF_Err%
        ;Se guarda el HANDLE del DOS en BX: 
        MOV BX,AX
    POP AX
    :OPF_AsNum
    PUSH AX
        ;Se guarda el HANDLE del DOS:
        PUSH BX
            MOV BX,%Handle%
            XOR AL,AL
            XCHG AL,AH
            ADD BX,AX
            ;Recupera n§_arch del DOS en AX
        POP AX
        MOV [BX],AL
    POP AX
POP BX
RET
        :OPF_EEZ0
        MOV AL,8
        JMP %OPF_Errmen5%
        :OPF_EEZ1
        MOV AL,9
        JMP %OPF_Errmen5%
        :OPF_EEZ3
        MOV AL,7
        JMP %OPF_Errmen5% 
        
       :Opf_Err
       CMP AL,5
       JNG %OPF_Errmen5%
       MOV AL,6
       :OPF_Errmen5 
       cmp al,2
       jnz %OPF_ErrNo2%
    pop ax
    push ax
        cmp al,1
        jz %OPF_Crear% 
        cmp al,2
        jz %OPF_Crear% 
        mov al,2 
        :OPF_ErrNo2
        push dx 
            MOV bx,%OPF_DirErr%
            xor ah,ah
            shl al ,1
            add bx,aX
            mov dx,[bx]
            mov ah,9
            int 21
            mov ah,9
            mov dx,%0a0d%
            int 21
        pop dx
    MOV AX,FFFF
    ;Hago POP porque hice un PUSH AX antes, pero no recupero AX.
    ;Al cambiar AX por FFFF indico un error al programa que llama a la
    ;rutina.
    pop BX
pop BX
ret 
        :OPF_Crear
    pop ax
    push ax
        mov ah,3c
        int 21 
        jc %OPF_ErrCre%
        mov ah,3e
        int 21 
    pop ax
pop bx
JMP %OPFIL%
        :OPF_ERRCRE
        MOV AL,a
        JMP %OPF_ERRMen5%
:OPF_DirErr
DB %OPF_E0%,%OPF_E0%,%OPF_E2%,%OPF_E3%,%OPF_E4%,%OPF_E5%,%OPF_E6%,%OPF_EZ%
DB %OPF_Ez1%,%OPF_Ez1%,%OPF_EC1%
:0a0d
db 0a 0d 24 
:OPF_E0
db "Error 0 o 1$"
:OPF_E2
db "Archivo no encontrado$"
:OPF_E4
db "Rebasado l¡mite de archivos$"
:OPF_E3
db "Ruta no encontrada$"
:OPF_e5 
db "Acceso negado$"
:OPF_e6
db "Error>6$"
;Este es el error 6 del DOS:
;No lo voy a utilizar porque tendr¡a que hacer demasiados cambios en el
;programa.
;:OPF_e6b
;db "N£mero de Arch. del DOS incorrecto$"
:OPF_eZ
db "N£mero de archivo abierto$"
:OPF_ez1 
db "N£mero de archivo incorrecto$" 
:OPF_EC1
db "Error al crear archivo$" 

:Handle
;Espacio para guardar 11 n£meros de archivo.(0-10) 
db 0 0 0 0 0 0 0 0 0 0 0 

:CLFIL
;Cerrar archivo abierto con OPFIL.
;PARAMS:
;AH= n£m_archivo
PUSH BX 
    ;Comprobaci¢n de la validez del primer par metro: N§ Control/Arch. 
    PUSH AX
        ;1: Si es "FF", cierra todos los archivos. 
        CMP Ah,FF
        JZ %CLF_TODOS% 
        ;2: No puede ser mayor de 10 (0Ah). 
        CMP Ah,0a
        JG %CLF_EEZ1%
        ;3: Si est  en uso lo cierra; en caso contrario, sale.
        MOV Bx,%HANDLE%
        PUSH AX
            XCHG AL,AH
            XOR AH,AH
            ADD BX,AX
        POP AX
        CMP by [BX],ff
        JZ %CLF_FIN%
        MOV BL,[BX]
        MOV BH,0
        MOV AH,3E
        INT 21
        :CLF_FIN
    POP AX
POP BX
RET
:CLF_TODOS
MOV AH,0
:CLF_RT
CALL %CLFIL%
INC AH
CMP AH,A
JLE %CLF_RT%
JMP %CLF_FIN%
        :CLF_EEZ1
        ;Utiliza el mensaje de error de OPF.
        ;(hay que ahorrar espacio: s¢lo dispongo de un segmento (64K).
        MOV DX,%OPF_EZ1%
        MOV AH,9
        INT 21
        MOV AX,FFFF
    POP BX
POP BX
RET

:RFIL
;Leer un archivo abierto con OPFIL
;AH= N§ archivo.
;AL=Leer (0)/Escribir (1).
;CX=Longitud.
;DS:DX?/DS:DI?/DOS Data Segment? = Posici¢n de E/S de informaci¢n.
PUSH BX 
    ;Comprobaci¢n de la validez del primer par metro: N§ Control/Arch. 
    PUSH AX
        ;1: No puede ser "FF". 
        CMP Ah,FF
        ;Utilizo las rut. de error de OPF.
        JNZ %RF_NE1%
        JMP %OPF_EEZ0% 
        :RF_NE1
        ;2: No puede ser mayor de 10 (0Ah). 
        CMP Ah,0a
        JLE %RF_NE2%
        JMP %OPF_EEZ1%
        :RF_NE2
        ;3: Ha de estar en uso. 
        MOV Bx,%HANDLE%
        PUSH AX
            XCHG AL,AH
            XOR AH,AH
            ADD BX,AX
        POP AX
        CMP by [BX],ff
        ;Para esto uso un nuevo mensaje de error.
        JZ %RF_EZ3%
        MOV BL,[BX]
        XOR BH,BH
    POP AX
    PUSH AX
        CMP AL,1
        JZ %RF_Escribe%
               MOV AH,3f
        :RF_I21
               ;Evito CY:
                PUSH BX
                    XOR BX,BX
                POP BX
                INT 21
                ;Aprovecho el gestor de errores de OPF para mostrar los
                ;de lectura de archivos.
                JNC %RF_I21_NOE%
                JMP %OPF_Err%
                :RF_I21_NOE
                JMP %RF_FIN%
        :RF_Escribe
            MOV AH,40
            JMP %RF_I21%
        :RF_FIN
    POP BX 
    ;^: Evito "PUSH AX."
POP BX
RET
        :RF_EZ3
        MOV DX,%RFERR%
        MOV AH,9
        INT 21
    MOV AX,FFFF
    POP BX
POP BX
RET
:RFERR
DB "N£mero de archivo no abierto.$"

:buffer1
db 0
#&a (%buffer1% 3c00 +)
:buffer2
db 0
#&a (%buffer2% 3c00 +)
:buffer3
db 0
</code>