md5::MD5Hash (private)

 md5::MD5Hash token msg

Defined in packages/acs-tcl/tcl/tcllib-doc-procs.tcl

Update the pure Tcl MD5 digest state with one 64-byte block.

Parameters:

token (required)

Internal MD5 digest state token.

msg (required)

Message block to process.

Partial Call Graph (max 5 caller/called nodes):

Testcases:

No testcase defined.

Source code:

    variable $token
    upvar 0 $token state

    #puts TR__=[Hex $msg]([string length $msg])

    # RFC1321:3.4 - Process Message in 16-Word Blocks
    binary scan $msg i* blocks
    foreach {X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15} $blocks {
        #puts BL

        set A $state(A)
        set B $state(B)
        set C $state(C)
        set D $state(D)

        # Round 1
        # Let [abcd k s i] denote the operation
        #   a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s).
        # Do the following 16 operations.
        # [ABCD  0  7  1]  [DABC  1 12  2]  [CDAB  2 17  3]  [BCDA  3 22  4]
        set A [expr {int($B + [<<< [expr {$A + ( ($B & $C) | ((~$B) & $D) ) + $X0 + 0xd76aa478}] 7])}]
        set D [expr {int($A + [<<< [expr {$D + ( ($A & $B) | ((~$A) & $C) ) + $X1 + 0xe8c7b756}] 12])}]
        set C [expr {int($D + [<<< [expr {$C + ( ($D & $A) | ((~$D) & $B) ) + $X2 + 0x242070db}] 17])}]
        set B [expr {int($C + [<<< [expr {$B + ( ($C & $D) | ((~$C) & $A) ) + $X3 + 0xc1bdceee}] 22])}]
        # [ABCD  4  7  5]  [DABC  5 12  6]  [CDAB  6 17  7]  [BCDA  7 22  8]
        set A [expr {int($B + [<<< [expr {$A + ( ($B & $C) | ((~$B) & $D) ) + $X4 + 0xf57c0faf}] 7])}]
        set D [expr {int($A + [<<< [expr {$D + ( ($A & $B) | ((~$A) & $C) ) + $X5 + 0x4787c62a}] 12])}]
        set C [expr {int($D + [<<< [expr {$C + ( ($D & $A) | ((~$D) & $B) ) + $X6 + 0xa8304613}] 17])}]
        set B [expr {int($C + [<<< [expr {$B + ( ($C & $D) | ((~$C) & $A) ) + $X7 + 0xfd469501}] 22])}]
        # [ABCD  8  7  9]  [DABC  9 12 10]  [CDAB 10 17 11]  [BCDA 11 22 12]
        set A [expr {int($B + [<<< [expr {$A + ( ($B & $C) | ((~$B) & $D) ) + $X8 + 0x698098d8}] 7])}]
        set D [expr {int($A + [<<< [expr {$D + ( ($A & $B) | ((~$A) & $C) ) + $X9 + 0x8b44f7af}] 12])}]
        set C [expr {int($D + [<<< [expr {$C + ( ($D & $A) | ((~$D) & $B) ) + $X10 + 0xffff5bb1}] 17])}]
        set B [expr {int($C + [<<< [expr {$B + ( ($C & $D) | ((~$C) & $A) ) + $X11 + 0x895cd7be}] 22])}]
        # [ABCD 12  7 13]  [DABC 13 12 14]  [CDAB 14 17 15]  [BCDA 15 22 16]
        set A [expr {int($B + [<<< [expr {$A + ( ($B & $C) | ((~$B) & $D) ) + $X12 + 0x6b901122}] 7])}]
        set D [expr {int($A + [<<< [expr {$D + ( ($A & $B) | ((~$A) & $C) ) + $X13 + 0xfd987193}] 12])}]
        set C [expr {int($D + [<<< [expr {$C + ( ($D & $A) | ((~$D) & $B) ) + $X14 + 0xa679438e}] 17])}]
        set B [expr {int($C + [<<< [expr {$B + ( ($C & $D) | ((~$C) & $A) ) + $X15 + 0x49b40821}] 22])}]

        # Round 2.
        # Let [abcd k s i] denote the operation
        #   a = b + ((a + G(b,c,d) + X[k] + Ti) <<< s)
        # Do the following 16 operations.
        # [ABCD  1  5 17]  [DABC  6  9 18]  [CDAB 11 14 19]  [BCDA  0 20 20]
        set A [expr {int($B + [<<< [expr {$A + ((($B & $D) | ($C & (~$D)))) + $X1  + 0xf61e2562}] 5])}]
        set D [expr {int($A + [<<< [expr {$D + ((($A & $C) | ($B & (~$C)))) + $X6  + 0xc040b340}] 9])}]
        set C [expr {int($D + [<<< [expr {$C + ((($D & $B) | ($A & (~$B)))) + $X11 + 0x265e5a51}] 14])}]
        set B [expr {int($C + [<<< [expr {$B + ((($C & $A) | ($D & (~$A)))) + $X0  + 0xe9b6c7aa}] 20])}]
        # [ABCD  5  5 21]  [DABC 10  9 22]  [CDAB 15 14 23]  [BCDA  4 20 24]
        set A [expr {int($B + [<<< [expr {$A + ((($B & $D) | ($C & (~$D)))) + $X5  + 0xd62f105d}] 5])}]
        set D [expr {int($A + [<<< [expr {$D + ((($A & $C) | ($B & (~$C)))) + $X10 + 0x2441453}] 9])}]
        set C [expr {int($D + [<<< [expr {$C + ((($D & $B) | ($A & (~$B)))) + $X15 + 0xd8a1e681}] 14])}]
        set B [expr {int($C + [<<< [expr {$B + ((($C & $A) | ($D & (~$A)))) + $X4  + 0xe7d3fbc8}] 20])}]
        # [ABCD  9  5 25]  [DABC 14  9 26]  [CDAB  3 14 27]  [BCDA  8 20 28]
        set A [expr {int($B + [<<< [expr {$A + ((($B & $D) | ($C & (~$D)))) + $X9  + 0x21e1cde6}] 5])}]
        set D [expr {int($A + [<<< [expr {$D + ((($A & $C) | ($B & (~$C)))) + $X14 + 0xc33707d6}] 9])}]
        set C [expr {int($D + [<<< [expr {$C + ((($D & $B) | ($A & (~$B)))) + $X3  + 0xf4d50d87}] 14])}]
        set B [expr {int($C + [<<< [expr {$B + ((($C & $A) | ($D & (~$A)))) + $X8  + 0x455a14ed}] 20])}]
        # [ABCD 13  5 29]  [DABC  2  9 30]  [CDAB  7 14 31]  [BCDA 12 20 32]
        set A [expr {int($B + [<<< [expr {$A + ((($B & $D) | ($C & (~$D)))) + $X13 + 0xa9e3e905}] 5])}]
        set D [expr {int($A + [<<< [expr {$D + ((($A & $C) | ($B & (~$C)))) + $X2  + 0xfcefa3f8}] 9])}]
        set C [expr {int($D + [<<< [expr {$C + ((($D & $B) | ($A & (~$B)))) + $X7  + 0x676f02d9}] 14])}]
        set B [expr {int($C + [<<< [expr {$B + ((($C & $A) | ($D & (~$A)))) + $X12 + 0x8d2a4c8a}] 20])}]
        
        # Round 3.
        # Let [abcd k s i] denote the operation
        #   a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s)
        # Do the following 16 operations.
        # [ABCD  5  4 33]  [DABC  8 11 34]  [CDAB 11 16 35]  [BCDA 14 23 36]
        set A [expr {int($B + [<<< [expr {$A + ($B ^ $C ^ $D) + $X5  + 0xfffa3942}] 4])}]
        set D [expr {int($A + [<<< [expr {$D + ($A ^ $B ^ $C) + $X8  + 0x8771f681}] 11])}]
        set C [expr {int($D + [<<< [expr {$C + ($D ^ $A ^ $B) + $X11 + 0x6d9d6122}] 16])}]
        set B [expr {int($C + [<<< [expr {$B + ($C ^ $D ^ $A) + $X14 + 0xfde5380c}] 23])}]
        # [ABCD  1  4 37]  [DABC  4 11 38]  [CDAB  7 16 39]  [BCDA 10 23 40]
        set A [expr {int($B + [<<< [expr {$A + ($B ^ $C ^ $D) + $X1  + 0xa4beea44}] 4])}]
        set D [expr {int($A + [<<< [expr {$D + ($A ^ $B ^ $C) + $X4  + 0x4bdecfa9}] 11])}]
        set C [expr {int($D + [<<< [expr {$C + ($D ^ $A ^ $B) + $X7  + 0xf6bb4b60}] 16])}]
        set B [expr {int($C + [<<< [expr {$B + ($C ^ $D ^ $A) + $X10 + 0xbebfbc70}] 23])}]
        # [ABCD 13  4 41]  [DABC  0 11 42]  [CDAB  3 16 43]  [BCDA  6 23 44]
        set A [expr {int($B + [<<< [expr {$A + ($B ^ $C ^ $D) + $X13 + 0x289b7ec6}] 4])}]
        set D [expr {int($A + [<<< [expr {$D + ($A ^ $B ^ $C) + $X0  + 0xeaa127fa}] 11])}]
        set C [expr {int($D + [<<< [expr {$C + ($D ^ $A ^ $B) + $X3  + 0xd4ef3085}] 16])}]
        set B [expr {int($C + [<<< [expr {$B + ($C ^ $D ^ $A) + $X6  + 0x4881d05}] 23])}]
        # [ABCD  9  4 45]  [DABC 12 11 46]  [CDAB 15 16 47]  [BCDA  2 23 48]
        set A [expr {int($B + [<<< [expr {$A + ($B ^ $C ^ $D) + $X9  + 0xd9d4d039}] 4])}]
        set D [expr {int($A + [<<< [expr {$D + ($A ^ $B ^ $C) + $X12 + 0xe6db99e5}] 11])}]
        set C [expr {int($D + [<<< [expr {$C + ($D ^ $A ^ $B) + $X15 + 0x1fa27cf8}] 16])}]
        set B [expr {int($C + [<<< [expr {$B + ($C ^ $D ^ $A) + $X2  + 0xc4ac5665}] 23])}]

        # Round 4.
        # Let [abcd k s i] denote the operation
        #   a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s)
        # Do the following 16 operations.
        # [ABCD  0  6 49]  [DABC  7 10 50]  [CDAB 14 15 51]  [BCDA  5 21 52]
        set A [expr {int($B + [<<< [expr {$A + ($C ^ ($B | (~$D))) + $X0  + 0xf4292244}] 6])}]
        set D [expr {int($A + [<<< [expr {$D + ($B ^ ($A | (~$C))) + $X7  + 0x432aff97}] 10])}]
        set C [expr {int($D + [<<< [expr {$C + ($A ^ ($D | (~$B))) + $X14 + 0xab9423a7}] 15])}]
        set B [expr {int($C + [<<< [expr {$B + ($D ^ ($C | (~$A))) + $X5  + 0xfc93a039}] 21])}]
        # [ABCD 12  6 53]  [DABC  3 10 54]  [CDAB 10 15 55]  [BCDA  1 21 56]
        set A [expr {int($B + [<<< [expr {$A + ($C ^ ($B | (~$D))) + $X12 + 0x655b59c3}] 6])}]
        set D [expr {int($A + [<<< [expr {$D + ($B ^ ($A | (~$C))) + $X3  + 0x8f0ccc92}] 10])}]
        set C [expr {int($D + [<<< [expr {$C + ($A ^ ($D | (~$B))) + $X10 + 0xffeff47d}] 15])}]
        set B [expr {int($C + [<<< [expr {$B + ($D ^ ($C | (~$A))) + $X1  + 0x85845dd1}] 21])}]
        # [ABCD  8  6 57]  [DABC 15 10 58]  [CDAB  6 15 59]  [BCDA 13 21 60]
        set A [expr {int($B + [<<< [expr {$A + ($C ^ ($B | (~$D))) + $X8  + 0x6fa87e4f}] 6])}]
        set D [expr {int($A + [<<< [expr {$D + ($B ^ ($A | (~$C))) + $X15 + 0xfe2ce6e0}] 10])}]
        set C [expr {int($D + [<<< [expr {$C + ($A ^ ($D | (~$B))) + $X6  + 0xa3014314}] 15])}]
        set B [expr {int($C + [<<< [expr {$B + ($D ^ ($C | (~$A))) + $X13 + 0x4e0811a1}] 21])}]
        # [ABCD  4  6 61]  [DABC 11 10 62]  [CDAB  2 15 63]  [BCDA  9 21 64]
        set A [expr {int($B + [<<< [expr {$A + ($C ^ ($B | (~$D))) + $X4  + 0xf7537e82}] 6])}]
        set D [expr {int($A + [<<< [expr {$D + ($B ^ ($A | (~$C))) + $X11 + 0xbd3af235}] 10])}]
        set C [expr {int($D + [<<< [expr {$C + ($A ^ ($D | (~$B))) + $X2  + 0x2ad7d2bb}] 15])}]
        set B [expr {int($C + [<<< [expr {$B + ($D ^ ($C | (~$A))) + $X9  + 0xeb86d391}] 21])}]

        # Then perform the following additions. (That is, increment each
        # of the four registers by the value it had before this block
        # was started.)
        incr state(A) $A
        incr state(B) $B
        incr state(C) $C
        incr state(D) $D
    }

    return

XQL Not present:

Generic, PostgreSQL, Oracle