$IF __PHILIPS != 2

$IF __PHILIPS != 0
$include(regmf2.inc)
$ENDIF


		NAME	DES						; Name of the module


?PR?DES?DES		SEGMENT CODE			; Segment for prg code in 'des'
		PUBLIC	_DES_CORE				; Public symbols for 'C' function call

		RSEG	?PR?DES?DES				; Program segment

; Table data for DES
BITS			EQU		020H				; The start of the bit-addressing block
BITS_0			EQU		020H				; The first  bit-addressing block (8 bytes)
BITS_1			EQU		028H				; The second bit-addressing block (8 bytes)
BUF				EQU		BITS_0			; The input block of the SP-box and the output buffer
; youyang 20030625
$IF __EMOSYN != 3
BLOCK			EQU		03DH
$ELSE
BLOCK			EQU		03CH
$ENDIF
;BLOCK			EQU		045H
B_DES			EQU		02FH.0

; S-Boxes
S1BOX:	
  	DB 0EFH, 003H, 041H, 0FDH, 0D8H, 074H, 01EH, 047H
	DB 026H, 0EFH, 0FBH, 022H, 0B3H, 0D8H, 084H, 01EH
	DB 039H, 0ACH, 0A7H, 060H, 062H, 0C1H, 0CDH, 0BAH
	DB 05CH, 096H, 090H, 059H, 005H, 03BH, 07AH, 085H
	DB 040H, 0FDH, 01EH, 0C8H, 0E7H, 08AH, 08BH, 021H
	DB 0DAH, 043H, 064H, 09FH, 02DH, 014H, 0B1H, 072H
	DB 0F5H, 05BH, 0C8H, 0B6H, 09CH, 037H, 076H, 0ECH
	DB 039H, 0A0H, 0A3H, 005H, 052H, 06EH, 00FH, 0D9H

S3BOX:	
    DB 0A7H, 0DDH, 00DH, 078H, 09EH, 00BH, 0E3H, 095H
	DB 060H, 036H, 036H, 04FH, 0F9H, 060H, 05AH, 0A3H
	DB 011H, 024H, 0D2H, 087H, 0C8H, 052H, 075H, 0ECH
	DB 0BBH, 0C1H, 04CH, 0BAH, 024H, 0FEH, 08FH, 019H
	DB 0DAH, 013H, 066H, 0AFH, 049H, 0D0H, 090H, 006H
	DB 08CH, 06AH, 0FBH, 091H, 037H, 08DH, 00DH, 078H
	DB 0BFH, 049H, 011H, 0F4H, 023H, 0E5H, 0CEH, 03BH
	DB 055H, 0BCH, 0A2H, 057H, 0E8H, 022H, 074H, 0CEH

S5BOX:	
    DB 02CH, 0EAH, 0C1H, 0BFH, 04AH, 024H, 01FH, 0C2H
	DB 079H, 047H, 0A2H, 07CH, 0B6H, 0D9H, 068H, 015H
	DB 080H, 056H, 05DH, 001H, 033H, 0FDH, 0F4H, 0AEH
	DB 0DEH, 030H, 007H, 09BH, 0E5H, 083H, 09BH, 068H
	DB 049H, 0B4H, 02EH, 083H, 01FH, 0C2H, 0B5H, 07CH
	DB 0A2H, 019H, 0D8H, 0E5H, 07CH, 02FH, 083H, 0DAH
	DB 0F7H, 06BH, 090H, 0FEH, 0C4H, 001H, 05AH, 097H
	DB 061H, 0A6H, 03DH, 040H, 00BH, 058H, 0E6H, 03DH

S7BOX:	
    DB 04DH, 0D1H, 0B2H, 00FH, 028H, 0BDH, 0E4H, 078H
	DB 0F6H, 04AH, 00FH, 093H, 08BH, 017H, 0D1H, 0A4H
	DB 03AH, 0ECH, 0C9H, 035H, 093H, 056H, 07EH, 0CBH
	DB 055H, 020H, 0A0H, 0FEH, 06CH, 089H, 017H, 062H
	DB 017H, 062H, 04BH, 0B1H, 0B4H, 0DEH, 0D1H, 087H
	DB 0C9H, 014H, 03CH, 04AH, 07EH, 0A8H, 0E2H, 07DH
	DB 0A0H, 09FH, 0F6H, 05CH, 06AH, 009H, 08DH, 0F0H
	DB 00FH, 0E3H, 053H, 025H, 095H, 036H, 028H, 0CBH

SBOX			EQU		S1BOX

; Rotation count in key-generation
; Pls note here the count series is the reversal of the conventional ones
; Since when processing loop, it is relatively easier to count DOWN than
; count UP, thus we reverse the direction of the table
LROT:			DB		1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, 1
RROT:			DB		1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, 0
; End of DES_DATA segment

;The DES encryption/decryption subroutine segment

; This module do NOT save ANY registers' value, and it do NOT use any stacks.
; It is up to the caller to care about stacks and registers.
; Register as parameters:
;		ACC is extensively used
;		B is used as CARRY buffer (only B.0 is used)
;		R0, R1 are used as counter and indexer
;		R5.0 == 1  --> With    Initial Permutation
;		R5.0 == 0  --> Without Initial Permutation
;		R5.1 == 1  --> With    Final   Permutation
; 		R5.1 == 0  --> Without Final   Permutation
;		R7 == 0 --> Encryption
; 		R7 == 1 --> Decryption
; Now Begins the subroutine.
;-------------------------------------------------------
_DES_CORE:

; Step 0: Initialize the key block (from 64-bit raw key to 64-bit key vector
; by PC-1 permutation (64 bits -> 56 bits)
PC_1:
	;Step 0: Hard-coded bit-moving scheme, the key vector is currently
	; located at (BITS+8) - (BITS+14)
 	MOV	A,R7
	JNB	ACC.0,SDF
	MOV	A,R5
	SETB	ACC.7
	MOV	R5,A
SDF:
;*********************************************
	MOV	R7,#08H
	MOV	R0,#27H

STEP01:	
	MOV	R1,#28H
	MOV	A,@R0		;BIT7
	RLC	A
	XCH	A,@R1
	RLC	A
	XCH	A,@R1
	
	RLC	A                ;BIT6
	INC	R1
       	XCH	A,@R1
	RLC	A
	XCH	A,@R1
                                 ;BIT5
	RLC	A
	INC	R1
       	XCH	A,@R1
	RLC	A
	XCH	A,@R1
	
	DEC	R0
	DJNZ	R7,STEP01
;*********************************************	

	MOV C, 27H.4
	RLC	A
	MOV C, 26H.4
	RLC	A
	MOV C, 25H.4
	RLC	A
	MOV C, 24H.4
	RLC	A
	MOV 	2BH,A


	MOV C, 23H.1
	RLC	A
	MOV C, 22H.1
	RLC	A
	MOV C, 21H.1
	RLC	A
	MOV C, 20H.1
	RLC	A
	MOV	 2CH,A


	MOV C, 23H.2
	RLC	A
	MOV C, 22H.2
	RLC	A
	MOV C, 21H.2
	RLC	A
	MOV C, 20H.2
	RLC	A
	MOV	2DH,A

;*********************************************
	MOV	R7,#04H
	MOV	R0,#27h

STEP02:	
	MOV	R1,#2BH
	MOV	A,@R0		;BIT1
	RRC	A
	RRC	A
	XCH	A,@R1
	RLC	A
	XCH	A,@R1
	
	RRC	A                ;BIT2
	INC	R1
       	XCH	A,@R1
	RLC	A
	XCH	A,@R1
                                 ;BIT3
	RRC	A
	INC	R1
       	XCH	A,@R1
	RLC	A
	XCH	A,@R1
	
	DEC	R0
	DJNZ	R7,STEP02
;*********************************************	

	MOV C, 23H.3
	RLC	A
	MOV C, 22H.3
	RLC	A
	MOV C, 21H.3
	RLC	A
	MOV C, 20H.3
	RLC	A
	MOV C, 23H.4
	RLC	A
	MOV C, 22H.4
	RLC	A
	MOV C, 21H.4
	RLC	A
	MOV C, 20H.4
	RLC	A
	MOV 	2EH,A


	; Now the processed key block is in (BITS_1) - (BITS_1+6)
; Step 1: Initial permutation of the BLOCK (IP)
	MOV A, R5
	JB ACC.0, IPERM
	JMP STEP_2
IPERM:
;****************************************
	MOV	R7,#04H
	MOV	R0,#BLOCK+4
	MOV	R1,#BLOCK+0
STEP34:	
	MOV	A,@R0
	SWAP	A
	MOV	@R0,A
	XRL	A,@R1
	ANL	A,#0F0H
	XCH	A,@R1
	XRL	A,@R1
	XCH	A,@R1
	XRL	A,@R0
	SWAP	A
	MOV	@R0,A

	INC	R0
	INC	R1
	DJNZ	R7,STEP34
;**********************************************

	MOV	R7,#02H
	MOV	R0,#BLOCK+2
	MOV	R1,#BLOCK+0
	LCALL	STEP12	


	MOV	R7,#02H
	MOV	R0,#BLOCK+6
	MOV	R1,#BLOCK+4
	LCALL	STEP12

;**********************************************

	MOV	R7,#04H
	MOV	R0,#BLOCK+1
	MOV	R1,#BLOCK
STEP13:	
	MOV	A,@R0
	RL	A
	MOV	@R0,A

	XRL	A,@R1
	ANL	A,#0AAH
	XCH	A,@R1
	XRL	A,@R1
	XCH	A,@R1
	XRL	A,@R0
	RR	A
	MOV	@R0,A

	INC	R0
	INC	R0
	INC	R1
	INC	R1
	DJNZ	R7,STEP13
;**********************************************

;--------------------------------------------------------
	; Step 1.4:
	XCH	A,BLOCK
	XCH	A,BLOCK+3
	XCH	A,BLOCK+6
	MOV	BLOCK,A

	XCH	A,BLOCK+7
	XCH	A,BLOCK+4
	XCH	A,BLOCK+1
	MOV	BLOCK+7,A


				; Step 1.5: Done
;===========================================================
;1== ***********************************************************
;===========================================================
STEP_2:
				; Step 2: The 16-run block processing
				; To maximize the speed, we un-roll the loop 
				; by factor 2 (16 round -> 8 round)
	MOV R1, #16 			; Initialize the count
LOOP_1:
				; The first part of the un-rolled loop
				; Step 2.1: Rotate the key vector
 
        CLR  B_DES
LH_DES_1:
	MOV A, R5
	JB  ACC.7,KEY_DE  	; If decryption, rotate right
	MOV DPTR, #LROT-1
	MOV A, R1
	MOVC A, @A+DPTR
	MOV R0, A		; Get the rotation counts and store
				; it in R0
				; Step 2.1L: Left-rotation, for the two 28-bit blocks respectively
LROT_0:	CLR C
	MOV A, BITS_1+6
	RLC A
	MOV BITS_1+6, A
	MOV A, BITS_1+5
	RLC A
	MOV BITS_1+5, A
	MOV A, BITS_1+4
	RLC A
	MOV BITS_1+4, A
	MOV A, BITS_1+3
	RLC A
	MOV BITS_1+3, A
	MOV B.0, C
	MOV C, ACC.4
	MOV (BITS_1+6).0, C
	MOV C, B.0
	MOV A, BITS_1+2
	RLC A
	MOV BITS_1+2, A
	MOV A, BITS_1+1
	RLC A
	MOV BITS_1+1, A
	MOV A, BITS_1
	RLC A
	MOV BITS_1, A
	MOV (BITS_1+3).4, C

	DJNZ R0, LROT_0
	SJMP STEP2_2

KEY_DE:
	MOV DPTR, #RROT-1
	MOV A, R1
	MOVC A, @A+DPTR
	JZ STEP2_2			; If no rotations, go directly
	MOV R0, A			; Get the rotation counts and store
					; it in R0
				; Step 2.2R: Right-rotation, for the two 28-bit blocks respectively
RROT_0:	CLR C
	MOV A, BITS_1
	RRC A
	MOV BITS_1, A
	MOV A, BITS_1+1
	RRC A
	MOV BITS_1+1, A
	MOV A, BITS_1+2
	RRC A
	MOV BITS_1+2, A
	MOV A, BITS_1+3
	RRC A
	MOV BITS_1+3, A
	MOV B.0, C
	MOV C, ACC.3
	MOV BITS_1.7, C
	MOV C, B.0
	MOV A, BITS_1+4
	RRC A
	MOV BITS_1+4, A
	MOV A, BITS_1+5
	RRC A
	MOV BITS_1+5, A
	MOV A, BITS_1+6
	RRC A
	MOV BITS_1+6, A
	MOV (BITS_1+3).3, C

	DJNZ R0, RROT_0

STEP2_2:
	; Step 2.2: Select the key using PC-2 permutation (56 bits -> 48 bits)
	; (hard-coded).
	; The permutated block is in (BITS_0) - (BITS_0 + 7)
	; i.e., (BUF) - (BUF+7)

	CLR	A
	MOV C, (BITS_1+1).2
	RLC	A
	MOV C, (BITS_1+2).7
	RLC	A
	MOV C, (BITS_1+1).5
	RLC	A
	MOV C, (BITS_1+2).0
	RLC	A
	MOV C, (BITS_1+0).7
	RLC	A
	MOV C, (BITS_1+0).3
	RLC	A
;-------------------------------------------------------------------------------
	ANL	(BUF+0),#11000000B		;*********
	ORL	(BUF+0),A
;-------------------------------------------------------------------------------
        CLR	A
	MOV C, (BITS_1+0).5
	RLC	A
	MOV C, (BITS_1+3).4
	RLC	A
	MOV C, (BITS_1+1).1
	RLC	A
	MOV C, (BITS_1+0).2
	RLC	A
	MOV C, (BITS_1+2).3
	RLC	A
	MOV C, (BITS_1+1).6
	RLC	A
;-------------------------------------------------------------------------------
       	ANL	(BUF+1),#11000000B		;*********
	ORL	(BUF+1),A

;-------------------------------------------------------------------------------	
	CLR	A
	MOV C, (BITS_1+2).1
	RLC	A	
	MOV C, (BITS_1+2).5
	RLC	A
	MOV C, (BITS_1+1).4
	RLC	A
	MOV C, (BITS_1+0).4
	RLC	A
	MOV C, (BITS_1+3).6
	RLC	A
	MOV C, (BITS_1+0).0
	RLC	A
;-------------------------------------------------------------------------------
	ANL	(BUF+2),#11000000B		;*********
	ORL	(BUF+2),A
;-------------------------------------------------------------------------------	
	CLR	A	
	MOV C, (BITS_1+1).0
	RLC	A
	MOV C, (BITS_1+0).1
	RLC	A
	MOV C, (BITS_1+3).5
	RLC	A
	MOV C, (BITS_1+2).4
	RLC	A
	MOV C, (BITS_1+1).3
	RLC	A
	MOV C, (BITS_1+0).6
	RLC	A
;-------------------------------------------------------------------------------
	ANL	(BUF+3),#11000000B		;*********
	ORL	(BUF+3),A
;-------------------------------------------------------------------------------		
        CLR	A
	MOV C, (BITS_1+5).7
	RLC	A
	MOV C, (BITS_1+6).4
	RLC	A
	MOV C, (BITS_1+3).1
	RLC	A
	MOV C, (BITS_1+4).3
	RLC	A
	MOV C, (BITS_1+5).1
	RLC	A
	MOV C, (BITS_1+6).1
	RLC	A
;-------------------------------------------------------------------------------
	ANL	(BUF+4),#11000000B		;*********
	ORL	(BUF+4),A
;-------------------------------------------------------------------------------		
        CLR	A
	MOV C, (BITS_1+3).2
	RLC	A
	MOV C, (BITS_1+4).0
	RLC	A
	MOV C, (BITS_1+6).5
	RLC	A
	MOV C, (BITS_1+5).3
	RLC	A
	MOV C, (BITS_1+4).7
	RLC	A
	MOV C, (BITS_1+5).0
	RLC	A