des Module Reference

Functions/Subroutines
ret	stream (type keyset, type message, type encrypt, type mode, type iv, optional kbits=64)
ret	createKeys (type key, optional weak=0)
Variables
variable	keys
variable	spfunction2 [list 0x80108020 0x80008000 0x8000 0x108020 0x100000 0x20 0x80100020 0x80008020 0x80000020 0x80108020 0x80108000 0x80000000 0x80008000 0x100000 0x20 0x80100020 0x108000 0x100020 0x80008020 0 0x80000000 0x8000 0x108020 0x80100000 0x100020 0x80000020 0 0x108000 0x8020 0x80108000 0x80100000 0x8020 0 0x108020 0x80100020 0x100000 0x80008020 0x80100000 0x80108000 0x8000 0x80100000 0x80008000 0x20 0x80108020 0x108020 0x20 0x8000 0x80000000 0x8020 0x80108000 0x100000 0x80000020 0x100020 0x80008020 0x80000020 0x100020 0x108000 0 0x80008000 0x8020 0x80000000 0x80100020 0x80108020 0x108000]
variable	spfunction3 [list 0x208 0x8020200 0 0x8020008 0x8000200 0 0x20208 0x8000200 0x20008 0x8000008 0x8000008 0x20000 0x8020208 0x20008 0x8020000 0x208 0x8000000 0x8 0x8020200 0x200 0x20200 0x8020000 0x8020008 0x20208 0x8000208 0x20200 0x20000 0x8000208 0x8 0x8020208 0x200 0x8000000 0x8020200 0x8000000 0x20008 0x208 0x20000 0x8020200 0x8000200 0 0x200 0x20008 0x8020208 0x8000200 0x8000008 0x200 0 0x8020008 0x8000208 0x20000 0x8000000 0x8020208 0x8 0x20208 0x20200 0x8000008 0x8020000 0x8000208 0x208 0x8020000 0x20208 0x8 0x8020008 0x20200]
variable	spfunction4 [list 0x802001 0x2081 0x2081 0x80 0x802080 0x800081 0x800001 0x2001 0 0x802000 0x802000 0x802081 0x81 0 0x800080 0x800001 0x1 0x2000 0x800000 0x802001 0x80 0x800000 0x2001 0x2080 0x800081 0x1 0x2080 0x800080 0x2000 0x802080 0x802081 0x81 0x800080 0x800001 0x802000 0x802081 0x81 0 0 0x802000 0x2080 0x800080 0x800081 0x1 0x802001 0x2081 0x2081 0x80 0x802081 0x81 0x1 0x2000 0x800001 0x2001 0x802080 0x800081 0x2001 0x2080 0x800000 0x802001 0x80 0x800000 0x2000 0x802080]
variable	spfunction5 [list 0x100 0x2080100 0x2080000 0x42000100 0x80000 0x100 0x40000000 0x2080000 0x40080100 0x80000 0x2000100 0x40080100 0x42000100 0x42080000 0x80100 0x40000000 0x2000000 0x40080000 0x40080000 0 0x40000100 0x42080100 0x42080100 0x2000100 0x42080000 0x40000100 0 0x42000000 0x2080100 0x2000000 0x42000000 0x80100 0x80000 0x42000100 0x100 0x2000000 0x40000000 0x2080000 0x42000100 0x40080100 0x2000100 0x40000000 0x42080000 0x2080100 0x40080100 0x100 0x2000000 0x42080000 0x42080100 0x80100 0x42000000 0x42080100 0x2080000 0 0x40080000 0x42000000 0x80100 0x2000100 0x40000100 0x80000 0 0x40080000 0x2080100 0x40000100]
variable	spfunction6 [list 0x20000010 0x20400000 0x4000 0x20404010 0x20400000 0x10 0x20404010 0x400000 0x20004000 0x404010 0x400000 0x20000010 0x400010 0x20004000 0x20000000 0x4010 0 0x400010 0x20004010 0x4000 0x404000 0x20004010 0x10 0x20400010 0x20400010 0 0x404010 0x20404000 0x4010 0x404000 0x20404000 0x20000000 0x20004000 0x10 0x20400010 0x404000 0x20404010 0x400000 0x4010 0x20000010 0x400000 0x20004000 0x20000000 0x4010 0x20000010 0x20404010 0x404000 0x20400000 0x404010 0x20404000 0 0x20400010 0x10 0x4000 0x20400000 0x404010 0x4000 0x400010 0x20004010 0 0x20404000 0x20000000 0x400010 0x20004010]
variable	spfunction7 [list 0x200000 0x4200002 0x4000802 0 0x800 0x4000802 0x200802 0x4200800 0x4200802 0x200000 0 0x4000002 0x2 0x4000000 0x4200002 0x802 0x4000800 0x200802 0x200002 0x4000800 0x4000002 0x4200000 0x4200800 0x200002 0x4200000 0x800 0x802 0x4200802 0x200800 0x2 0x4000000 0x200800 0x4000000 0x200800 0x200000 0x4000802 0x4000802 0x4200002 0x4200002 0x2 0x200002 0x4000000 0x4000800 0x200000 0x4200800 0x802 0x200802 0x4200800 0x802 0x4000002 0x4200802 0x4200000 0x200800 0 0x2 0x4200802 0 0x200802 0x4200000 0x800 0x4000002 0x4000800 0x800 0x200002]
variable	spfunction8 [list 0x10001040 0x1000 0x40000 0x10041040 0x10000000 0x10001040 0x40 0x10000000 0x40040 0x10040000 0x10041040 0x41000 0x10041000 0x41040 0x1000 0x40 0x10040000 0x10000040 0x10001000 0x1040 0x41000 0x40040 0x10040040 0x10041000 0x1040 0 0 0x10040040 0x10000040 0x10001000 0x41040 0x40000 0x41040 0x40000 0x10041000 0x1000 0x40 0x10040040 0x1000 0x41040 0x10001000 0x40 0x10000040 0x10040000 0x10040040 0x10000000 0x40000 0x10001040 0 0x10041040 0x40040 0x10000040 0x10040000 0x10001000 0x10001040 0 0x10041040 0x41000 0x41000 0x1040 0x1040 0x40040 0x10000000 0x10041000]

---

Function/Subroutine Documentation

ret des::createKeys	(	type	key,
		optional	weak = 0
	)

Definition at line 923 of file tcldesjr.tcl.

References error(), and keys.

                                                  {
    variable pc2bytes0
    variable pc2bytes1
    variable pc2bytes2
    variable pc2bytes3
    variable pc2bytes4
    variable pc2bytes5
    variable pc2bytes6
    variable pc2bytes7
    variable pc2bytes8
    variable pc2bytes9
    variable pc2bytes10
    variable pc2bytes11
    variable pc2bytes12
    variable pc2bytes13
    variable shifts

    # Stores the return keys
    set keys {}
    # Other variables
    set lefttemp {}; set righttemp {}
    binary scan $key H8H8 lefttemp righttemp
    set left {}
    append left "0x" $lefttemp
    set right {}
    append right "0x" $righttemp

    #puts "Left key: $left"
    #puts "Right key: $right"

    # Test for weak keys
        if {! $weak} {
            set maskedLeft [expr {$left & 0xfefefefe}]
            set maskedRight [expr {$right & 0xfefefefe}]
            if {($maskedLeft == 0x00000000) \
                    && ($maskedRight == 0x00000000)} {
                error "The key is weak!"
            } elseif {($maskedLeft == 0x1e1e1e1e) \
                          && ($maskedRight == 0x0e0e0e0e)} {
                error "The key is weak!"
            } elseif {($maskedLeft == 0xe0e0e0e0) \
                          && ($maskedRight == 0xf0f0f0f0)} {
                error "The key is weak!"
            } elseif {($maskedLeft == 0xfefefefe) \
                          && ($maskedRight == 0xfefefefe)} {
                error "The key is weak!"
            }
        }

    set temp [expr {(($left >> 4) ^ $right) & 0x0f0f0f0f}]
    set right [expr {$right ^ $temp}]
    set left [expr {$left ^ ($temp << 4)}]
    set temp [expr {(($right >> 16) ^ $left) & 0x0000ffff}]
    set left [expr {$left ^ $temp}]
    set right [expr {$right ^ ($temp << 16)}]
    set temp [expr {(($left >> 2) ^ $right) & 0x33333333}]
    set right [expr {$right ^ $temp}]
    set left [expr {$left ^ ($temp << 2)}]
    set temp [expr {(($right >> 16) ^ $left) & 0x0000ffff}]
    set left [expr {$left ^ $temp}]
    set right [expr {$right ^ ($temp << 16)}]
    set temp [expr {(($left >> 1) ^ $right) & 0x55555555}]
    set right [expr {$right ^ $temp}]
    set left [expr {$left ^ ($temp << 1)}]
    set temp [expr {(($right >> 8) ^ $left) & 0x00ff00ff}]
    set left [expr {$left ^ $temp}]
    set right [expr {$right ^ ($temp << 8)}]
    set temp [expr {(($left >> 1) ^ $right) & 0x55555555}]
    set right [expr $right ^ $temp]
    set left [expr {$left ^ ($temp << 1)}]
        
    # puts "Left key PC1: [format %x $left]"
    # puts "Right key PC1: [format %x $right]"

    # The right side needs to be shifted and to get
    # the last four bits of the left side
    set temp [expr {($left << 8) | (($right >> 20) & 0x000000f0)}];
    # Left needs to be put upside down
    set left [expr {($right << 24) | (($right << 8) & 0x00ff0000) | \
                (($right >> 8) & 0x0000ff00) \
                | (($right >> 24) & 0x000000f0)}];
    set right $temp;

    #puts "Left key juggle: [format %x $left]"
    #puts "Right key juggle: [format %x $right]"

    # Now go through and perform these
    # shifts on the left and right keys.
    foreach i $shifts  {
        # Shift the keys either one or two bits to the left.
        if {$i} {
        set left [expr {($left << 2) \
                    | (($left >> 26) & 0x0000003f)}];
        set right [expr {($right << 2) \
                     | (($right >> 26) & 0x0000003f)}];
        } else {
        set left [expr {($left << 1) \
                    | (($left >> 27) & 0x0000001f)}];
        set right [expr {($right << 1) \
                     | (($right >> 27) & 0x0000001f)}];
        }
        set left [expr {$left & 0xfffffff0}];
        set right [expr {$right & 0xfffffff0}];

        # Now apply PC-2, in such a way that E is easier when encrypting or
        # decrypting this conversion will look like PC-2 except only the
        # last 6 bits of each byte are used rather than 48 consecutive bits
        # and the order of lines will be according to how the S selection
        # functions will be applied: S2, S4, S6, S8, S1, S3, S5, S7.
        set lefttemp [expr {[lindex $pc2bytes0 [expr {($left >> 28) & 0x0000000f}]] | \
                    [lindex $pc2bytes1 [expr {($left >> 24) & 0x0000000f}]] | \
                    [lindex $pc2bytes2 [expr {($left >> 20) & 0x0000000f}]] | \
                    [lindex $pc2bytes3 [expr {($left >> 16) & 0x0000000f}]] | \
                    [lindex $pc2bytes4 [expr {($left >> 12) & 0x0000000f}]] | \
                    [lindex $pc2bytes5 [expr {($left >> 8) & 0x0000000f}]] | \
                    [lindex $pc2bytes6 [expr {($left >> 4) & 0x0000000f}]]}];
        set righttemp [expr {[lindex $pc2bytes7 [expr {($right >> 28) & 0x0000000f}]] | \
                     [lindex $pc2bytes8 [expr {($right >> 24) & 0x0000000f}]] | \
                     [lindex $pc2bytes9 [expr {($right >> 20) & 0x0000000f}]] | \
                     [lindex $pc2bytes10 [expr {($right >> 16) & 0x0000000f}]] | \
                     [lindex $pc2bytes11 [expr {($right >> 12) & 0x0000000f}]] | \
                     [lindex $pc2bytes12 [expr {($right >> 8) & 0x0000000f}]] | \
                     [lindex $pc2bytes13 [expr {($right >> 4) & 0x0000000f}]]}];
        set temp [expr {(($righttemp >> 16) ^ $lefttemp) & 0x0000ffff}];
        lappend keys [expr {$lefttemp ^ $temp}];
        lappend keys [expr {$righttemp ^ ($temp << 16)}];
    }
    # Return the keys we've created.
    return $keys;
    }; /*  End of createKeys.*/

Here is the call graph for this function:

ret des::stream	(	type	keyset,
		type	message,
		type	encrypt,
		type	mode,
		type	iv,
		optional	kbits = 64
	)

Definition at line 481 of file tcldesjr.tcl.

References error(), keys, spfunction2, spfunction3, spfunction4, spfunction5, spfunction6, spfunction7, and spfunction8.

                                                                                                       {
    variable spfunction1
    variable spfunction2
    variable spfunction3
    variable spfunction4
    variable spfunction5
    variable spfunction6
    variable spfunction7
    variable spfunction8
    variable desEncrypt
    variable keysets

    # Determine if the keyset handle is valid.
    if {[array names keysets $keyset] != {}} {
        # Acquire the 16 subkeys we will need.
        set keys $keysets($keyset)
    } else {
        error "The keyset handle \"$keyset\" is invalid!"
    }

    # Is the initialization/feedback vector variable is valid?
    if {[string length $iv] < 1} {
        error "An initialization variable must be specified."
    } else {
        upvar $iv ivec
        if {![info exists ivec]} {
        error "The variable $iv does not exist."
        }
    }

        # Determine if message length (in bits)
    # is not an integral number of kbits.
    set len [string length $message];
        #puts "len: $len, kbits: $kbits"
    if {($kbits < 1) || ($kbits > 64)} {
        error "The valid values of kbits are 1 through 64."
        } elseif {($kbits % 8) != 0} {
        set blockSize [expr {$kbits + (8 - ($kbits % 8))}]
        set fail [expr {(($len * 8) / $blockSize) % $kbits}]
    } else {
        set blockSize [expr {$kbits / 8}]
        set fail [expr {$len % $blockSize}]
    }
        if {$fail} {
        error "Data length (in bits) is not an integral number of kbits."
    }

    set m 0
    set n 0
    set chunk 0;
    # Set up the loops for des
    set looping $desEncrypt

        # Set up shifting values.  Used for both CFB and OFB modes.
        if {$kbits < 32} {
        # Only some bits from left output are needed.
        set kOutShift [expr {32 - $kbits}]
        set kOutMask [expr {0x7fffffff >> (31 - $kbits)}]
        # Determine number of message bytes needed per iteration.
        set msgBytes [expr {int(ceil(double($kbits) / 8.0))}]
        # Determine number of message bits needed per iteration.
        set msgBits [expr {$msgBytes * 8}]
        set msgBitsSub1 [expr {$msgBits - 1}]
        # Define bit caches.
        set bitCacheIn {}
        set bitCacheOut {}
        # Variable used to remove bits 0 through
        # kbits-1 in the input bit cache.
        set kbitsSub1 [expr {$kbits - 1}]
        # Variable used to remove leading dummy binary bits.
        set xbits [expr {32 - $kbits}]
    } elseif {$kbits == 32} {
        # Only bits of left output are used.
        # Four messages bytes are needed per iteration.
        set msgBytes 4
        set xbits 32
    } elseif {$kbits < 64} {
        # All bits from left output are needed.
        set kOutShiftLeft [expr {$kbits - 32}]
        # Some bits from right output are needed.
        set kOutShiftRight [expr {64 - $kbits}]
        set kOutMaskRight [expr {0x7fffffff >> (63 - $kbits)}]
        # Determine number of message bytes needed per iteration.
        set msgBytes [expr {int(ceil(double($kbits) / 8.0))}]
        # Determine number of message bits needed per iteration.
        set msgBits [expr {$msgBytes * 8}]
        set msgBitsSub1 [expr {$msgBits - 1}]
        # Define bit caches.
        set bitCacheIn {}
        set bitCacheOut {}
        # Variable used to remove bits 0 through
        # kbits-1 in the input bit cache.
        set kbitsSub1 [expr {$kbits - 1}]
        # Variable used to remove leading dummy binary bits.
        set xbits [expr {64 - $kbits}]
    } else {
        # All 64 bits of output are used.
        # Eight messages bytes are needed per iteration.
        set msgBytes 8
        set xbits 0
    }

    # Store the result here
    set result {}
    set tempresult {}

    # Set up the initialization vector bitstream
    binary scan $ivec H8H8 leftTemp rightTemp
    set left "0x$leftTemp"
    set right "0x$rightTemp"
        #puts "Retrieved Feedback vector: $fbvec"
        #puts "Start: |$left| |$right|"
    
    # Loop through each 64 bit chunk of the message
    while {$m < $len} {
        # puts "Left start: $left";
        # puts "Right start: $right";

        # First each 64 but chunk of the
        # message must be permuted according to IP.
        set temp [expr {(($left >> 4) ^ $right) & 0x0f0f0f0f}];
        set right [expr {$right ^ $temp}];
        set left [expr {$left ^ ($temp << 4)}];
        set temp [expr {(($left >> 16) ^ $right) & 0x0000ffff}];
        set right [expr {$right ^ $temp}];
        set left [expr {$left ^ ($temp << 16)}];
        set temp [expr {(($right >> 2) ^ $left) & 0x33333333}];
        set left [expr {$left ^ $temp}];
        set right [expr {$right ^ ($temp << 2)}];

        set temp [expr {(($right >> 8) ^ $left) & 0x00ff00ff}];
        set left [expr {$left ^ $temp}];
        set right [expr {$right ^ ($temp << 8)}];
        set temp [expr {(($left >> 1) ^ $right) & 0x55555555}];
        set right [expr {$right ^ $temp}];
        set left [expr {$left ^ ($temp << 1)}];

        set left [expr {((($left << 1) & 0xffffffff) | \
                 (($left >> 31) & 0x00000001))}]; 
        set right [expr {((($right << 1) & 0xffffffff) | \
                  (($right >> 31) & 0x00000001))}]; 

        #puts "Left IP: [format %x $left]";
        #puts "Right IP: [format %x $right]";

        # Do this 1 time for each chunk of the message
        set endloop [lindex $looping 1];
        set loopinc [lindex $looping 2];

        # puts "endloop: $endloop";
        # puts "loopinc: $loopinc";

        # Now go through and perform the encryption or decryption  
        for {set i [lindex $looping 0]} \
        {$i != $endloop} {incr i $loopinc} {
        # For efficiency
        set right1 [expr {$right ^ [lindex $keys $i]}]; 
        set right2 [expr {((($right >> 4) & 0x0fffffff) | \
                       (($right << 28) & 0xffffffff)) ^ \
                      [lindex $keys [expr {$i + 1}]]}];
 
        # puts "right1: [format %x $right1]";
        # puts "right2: [format %x $right2]";

        # The result is attained by passing these
        # bytes through the S selection functions.
        set temp $left;
        set left $right;
        set right [expr {$temp ^ ([lindex $spfunction2 [expr {($right1 >> 24) & 0x3f}]] | \
                          [lindex $spfunction4 [expr {($right1 >> 16) & 0x3f}]] | \
                          [lindex $spfunction6 [expr {($right1 >>  8) & 0x3f}]] | \
                          [lindex $spfunction8 [expr {$right1 & 0x3f}]] | \
                          [lindex $spfunction1 [expr {($right2 >> 24) & 0x3f}]] | \
                          [lindex $spfunction3 [expr {($right2 >> 16) & 0x3f}]] | \
                          [lindex $spfunction5 [expr {($right2 >>  8) & 0x3f}]] | \
                          [lindex $spfunction7 [expr {$right2 & 0x3f}]])}];
 
        # puts "Left iter: [format %x $left]";
        # puts "Right iter: [format %x $right]";
        }
        set temp $left;
        set left $right;
        set right $temp; # Unreverse left and right

        #puts "Left Iterated: [format %x $left]";
        #puts "Right Iterated: [format %x $right]";

        # Move then each one bit to the right
        set left [expr {((($left >> 1) & 0x7fffffff) | \
                 (($left << 31) & 0xffffffff))}]; 
        set right [expr {((($right >> 1) & 0x7fffffff) | \
                  (($right << 31) & 0xffffffff))}]; 

        #puts "Left shifted: [format %x $left]";
        #puts "Right shifted: [format %x $right]";

        # Now perform IP-1, which is IP in the opposite direction
        set temp [expr {((($left >> 1) & 0x7fffffff) ^ $right) & 0x55555555}];
        set right [expr {$right ^ $temp}];
        set left [expr {$left ^ ($temp << 1)}];
        set temp [expr {((($right >> 8) & 0x00ffffff) ^ $left) & 0x00ff00ff}];
        set left [expr {$left ^ $temp}];
        set right [expr {$right ^ ($temp << 8)}];
        set temp [expr {((($right >> 2) & 0x3fffffff) ^ $left) & 0x33333333}]; 
        set left [expr {$left ^ $temp}];
        set right [expr {$right ^ ($temp << 2)}];
        set temp [expr {((($left >> 16) & 0x0000ffff) ^ $right) & 0x0000ffff}];
        set right [expr {$right ^ $temp}];
        set left [expr {$left ^ ($temp << 16)}];
        set temp [expr {((($left >> 4) & 0x0fffffff) ^ $right) & 0x0f0f0f0f}];
        set right [expr {$right ^ $temp}];
        set left [expr {$left ^ ($temp << 4)}];

        #puts "Left IP-1: [format %x $left]";
        #puts "Right IP-1: [format %x $right]";

        # Extract the "kbits" most significant bits from the output block.
        if {$kbits < 32} {
        # Only some bits from left output are needed.
        set kData [expr {($left >> $kOutShift) & $kOutMask}]
        set newBits {}
        # If necessary, copy message bytes into input bit cache.
        if {([string length $bitCacheIn] < $kbits) && ($n < $len)} {
            if {$len - $n < $msgBytes} {
            set lastBits [expr {($len - $n) * 8}]
            ###puts -nonewline [binary scan $message x${n}B$lastBits newBits]
            binary scan $message x${n}B$lastBits newBits
            } else {
            # Extract "msgBytes" whole bytes as bits
            ###puts -nonewline [binary scan $message x${n}B$msgBits newBits]
            binary scan $message x${n}B$msgBits newBits
            }
            incr n $msgBytes
            #puts " $newBits  $n [expr {$len - $n}]"
            # Add the bits to the input bit cache.
            append bitCacheIn $newBits
        }
        #puts -nonewline "In bit cache: $bitCacheIn"
        # Set up message data from input bit cache.
        binary scan [binary format B32 [format %032s [string range $bitCacheIn 0 $kbitsSub1]]] H8 temp
        set msgData "0x$temp"
        # Mix message bits with crypto bits.
        set mixData [expr {$msgData ^ $kData}]
        # Discard collected bits from the input bit cache.
        set bitCacheIn [string range $bitCacheIn $kbits end]
        #puts "  After: $bitCacheIn"
        # Convert back to a bit stream and append to the output bit cache.
        # Only the lower kbits are wanted.
        binary scan [binary format H8 [format %08x $mixData]] B32 msgOut
        append bitCacheOut [string range $msgOut $xbits end]
        #puts -nonewline "Out bit cache: $bitCacheOut"
        # If there are sufficient bits, move bytes to the temporary holding string.
        if {[string length $bitCacheOut] >= $msgBits} {
            append tempresult [binary format B$msgBits [string range $bitCacheOut 0 $msgBitsSub1]]
            set bitCacheOut [string range $bitCacheOut $msgBits end]
                    #puts -nonewline "  After: $bitCacheOut"
            incr m $msgBytes
            ###puts "$m bytes output"
            incr chunk $msgBytes
        }
        #puts ""
        # For CFB mode
        if {$mode == 1} {
            if {$encrypt} {
            set temp [expr {($right << $kbits) & 0xffffffff}]
            set left [expr {(($left << $kbits) & 0xffffffff) | (($right >> $kOutShift) & $kOutMask)}]
            set right [expr {$temp | $mixData}]
            } else {
            set temp [expr {($right << $kbits) & 0xffffffff}]
            set left [expr {(($left << $kbits) & 0xffffffff) | (($right >> $kOutShift) & $kOutMask)}]
            set right [expr {$temp | $msgData}]
            }
        }
        } elseif {$kbits == 32} {
        # Only bits of left output are used.
        set kData $left
        # Four messages bytes are needed per iteration.
        binary scan $message x${m}H8 temp
        incr m 4
        incr chunk 4
        set msgData "0x$temp"
        # Mix message bits with crypto bits.
        set mixData [expr {$msgData ^ $kData}]
        # Move bytes to the temporary holding string.
        append tempresult [binary format H8 [format %08x $mixData]]
        # For CFB mode
        if {$mode == 1} {
            set left $right
            if {$encrypt} {
            set right $mixData
            } else {
            set right $msgData
            }
        }
        } elseif {$kbits < 64} {
        set kDataLeft [expr {($left >> $kOutShiftRight) & $kOutMaskRight}]
        set temp [expr {($left << $kOutShiftLeft) & 0xffffffff}]
        set kDataRight [expr {(($right >> $kOutShiftRight) & $kOutMaskRight) | $temp}]
        # If necessary, copy message bytes into input bit cache.
        if {([string length $bitCacheIn] < $kbits)  && ($n < $len)} {
            if {$len - $n < $msgBytes} {
            set lastBits [expr {($len - $n) * 8}]
            ###puts -nonewline [binary scan $message x${n}B$lastBits newBits]
            binary scan $message x${n}B$lastBits newBits
            } else {
            # Extract "msgBytes" whole bytes as bits
            ###puts -nonewline [binary scan $message x${n}B$msgBits newBits]
            binary scan $message x${n}B$msgBits newBits
            }
            incr n $msgBytes
            # Add the bits to the input bit cache.
            append bitCacheIn $newBits
        }
        # Set up message data from input bit cache.
        # puts "Bits from cache: [set temp [string range $bitCacheIn 0 $kbitsSub1]]"
        # puts "Length of bit string: [string length $temp]"
        binary scan [binary format B64 [format %064s [string range $bitCacheIn 0 $kbitsSub1]]] H8H8 leftTemp rightTemp
        set msgDataLeft "0x$leftTemp"
        set msgDataRight "0x$rightTemp"
        # puts "msgDataLeft: $msgDataLeft"
        # puts "msgDataRight: $msgDataRight"
        # puts "kDataLeft: [format 0x%08x $kDataLeft]"
        # puts "kDataRight: [format 0x%08x $kDataRight]"
        # Mix message bits with crypto bits.
        set mixDataLeft [expr {$msgDataLeft ^ $kDataLeft}]
        set mixDataRight [expr {$msgDataRight ^ $kDataRight}]
        # puts "mixDataLeft: $mixDataLeft"
        # puts "mixDataRight: $mixDataRight"
        # puts "mixDataLeft: [format 0x%08x $mixDataLeft]"
        # puts "mixDataRight: [format 0x%08x $mixDataRight]"
        # Discard collected bits from the input bit cache.
        set bitCacheIn [string range $bitCacheIn $kbits end]
        # Convert back to a bit stream and
        # append to the output bit cache.
        # Only the lower kbits are wanted.
        binary scan \
            [binary format H8H8 \
             [format %08x $mixDataLeft] \
             [format %08x $mixDataRight]] B64 msgOut
        append bitCacheOut [string range $msgOut $xbits end]
        # If there are sufficient bits, move
        # bytes to the temporary holding string.
        if {[string length $bitCacheOut] >= $msgBits} {
            append tempresult \
            [binary format B$msgBits \
                 [string range $bitCacheOut 0 $msgBitsSub1]]
            set bitCacheOut [string range $bitCacheOut $msgBits end]
            incr m $msgBytes
            incr chunk $msgBytes
        }
        # For CFB mode
        if {$mode == 1} {
            if {$encrypt} {
            set temp \
                [expr {($right << $kOutShiftRight) & 0xffffffff}]
            set left [expr {$temp | $mixDataLeft}]
            set right $mixDataRight
            } else {
            set temp \
                [expr {($right << $kOutShiftRight) & 0xffffffff}]
            set left [expr {$temp | $msgDataLeft}]
            set right $msgDataRight
            }
        }
        } else {
        # All 64 bits of output are used.
        set kDataLeft $left
        set kDataRight $right
        # Eight messages bytes are needed per iteration.
        binary scan $message x${m}H8H8 leftTemp rightTemp
        incr m 8
        incr chunk 8
        set msgDataLeft "0x$leftTemp"
        set msgDataRight "0x$rightTemp"
        # Mix message bits with crypto bits.
        set mixDataLeft [expr {$msgDataLeft ^ $kDataLeft}]
        set mixDataRight [expr {$msgDataRight ^ $kDataRight}]
        # Move bytes to the temporary holding string.
        append tempresult \
            [binary format H16 \
             [format %08x%08x $mixDataLeft $mixDataRight]]
        # For CFB mode
        if {$mode == 1} {
            if {$encrypt} {
            set left $mixDataLeft
            set right $mixDataRight
            } else {
            set left $msgDataLeft
            set right $msgDataRight
            }
        }
        }

        #puts "Left final: [format %08x $left]";
        #puts "Right final: [format %08x $right]"

        if {$chunk >= 512} {
        append result $tempresult
        set tempresult {};
        set chunk 0;
        }
    }; # For every 8 characters, or 64 bits in the message
        #puts "End: |[format 0x%08x $left]| |[format 0x%08x $right]|"
    # Save the left and right registers to the feedback vector.
    set ivec [binary format H* [format %08x $left][format %08x $right]]
    #puts "Saved Feedback vector: $fbvectors($fbvector)"

        append result $tempresult
    if {[string length $result] > $len} {
        set result [string replace $result $len end]
    }
    # Return the result as an array
    return $result
    }; /*  End of stream*/

Here is the call graph for this function:

---

Variable Documentation

variable des::keys

Definition at line 68 of file tcldes.tcl.

Referenced by createKeys(), and stream().

variable des::spfunction2

Definition at line 212 of file tcldes.tcl.

Referenced by stream().

variable des::spfunction3

Definition at line 213 of file tcldes.tcl.

Referenced by stream().

variable des::spfunction4

Definition at line 214 of file tcldes.tcl.

Referenced by stream().

variable des::spfunction5

Definition at line 215 of file tcldes.tcl.

Referenced by stream().

variable des::spfunction6

Definition at line 216 of file tcldes.tcl.

Referenced by stream().

variable des::spfunction7

Definition at line 217 of file tcldes.tcl.

Referenced by stream().

variable des::spfunction8

Definition at line 218 of file tcldes.tcl.

Referenced by stream().