CRIPTOGRAFIE

[!_30]

Pseudocode for the MD5 algorithm follows.

//Note: All variables are unsigned 32 bits and wrap modulo 2^32 when calculating

//Define r as the following

var int[64] r, k

r[ 0..15] := {7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22}

r[16..31] := {5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20}

r[32..47] := {4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23}

r[48..63] := {6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21}

//Use binary integer part of the sines of integers as constants:

for i from 0 to 63

    k := floor(abs(sin(i + 1)) Ã 2^32)

//Initialize variables:

var int h0 := 0x67452301

var int h1 := 0xEFCDAB89

var int h2 := 0x98BADCFE

var int h3 := 0x10325476

//Pre-processing:

append "1" bit to message

append "0" bits until message length in bits ? 448 (mod 512)

append bit length of message as 64-bit little-endian integer to message

//Process the message in successive 512-bit chunks:

for each 512-bit chunk of message

    break chunk into sixteen 32-bit little-endian words w(i), 0 ? i ? 15

    //Initialize hash value for this chunk:

    var int a := h0

    var int b := h1

    var int c := h2

    var int d := h3

    //Main loop:

    for i from 0 to 63

        if 0 ? i ? 15 then

            f := (b and c) or ((not and d)

            g := i

        else if 16 ? i ? 31

            f := (d and or ((not d) and c)

            g := (5Ãâ€â€Âi + 1) mod 16

        else if 32 ? i ? 47

            f := b xor c xor d

            g := (3Ãâ€â€Âi + 5) mod 16

        else if 48 ? i ? 63

            f := c xor (b or (not d))

            g := (7Ãâ€â€Âi) mod 16

        temp := d

        d := c

        c := b

        b := ((a + f + k + w(g)) leftrotate r) + b

        a := temp

    //Add this chunk's hash to result so far:

    h0 := h0 + a

    h1 := h1 + b

    h2 := h2 + c

    h3 := h3 + d

var int digest := h0 append h1 append h2 append h3 //(expressed as little-endian)

MD4

http://en.wikipedia.org/wiki/MD4

MD2

http://en.wikipedia.org/wiki/MD2

SHA-0,1,2

SHA-1 was considered to be the successor to MD5, an earlier, widely-used hash function. Both are reportedly compromised. In some circles, it is suggested that SHA-256 or greater be used for critical technology. The SHA algorithms were designed by the National Security Agency (NSA) and published as a US government standard.

Note: All variables are unsigned 32 bits and wrap modulo 2^32 when calculating

Initialize variables:

h0 := 0x67452301

h1 := 0xEFCDAB89

h2 := 0x98BADCFE

h3 := 0x10325476

h4 := 0xC3D2E1F0

Pre-processing:

append a single "1" bit to message

append "0" bits until message length in bits ? 448 ? -64 (mod 512)

append length of message (before pre-processing), in bits as 64-bit big-endian integer to message

Process the message in successive 512-bit chunks:

break message into 512-bit chunks

for each chunk

    break chunk into sixteen 32-bit big-endian words w(i), 0 ? i ? 15

    Extend the sixteen 32-bit words into eighty 32-bit words:

    for i from 16 to 79

        w(i) := (w(i-3) xor w(i- xor w(i-14) xor w(i-16)) leftrotate 1

    Initialize hash value for this chunk:

    a := h0

    b := h1

    c := h2

    d := h3

    e := h4

    Main loop:

    for i from 0 to 79

        if 0 ? i ? 19 then

            f := (b and c) or ((not and d)

            k := 0x5A827999

        else if 20 ? i ? 39

            f := b xor c xor d

            k := 0x6ED9EBA1

        else if 40 ? i ? 59

            f := (b and c) or (b and d) or (c and d)

            k := 0x8F1BBCDC

        else if 60 ? i ? 79

            f := b xor c xor d

            k := 0xCA62C1D6

        temp := (a leftrotate 5) + f + e + k + w(i)

        e := d

        d := c

        c := b leftrotate 30

        b := a

        a := temp

    Add this chunk's hash to result so far:

    h0 := h0 + a

    h1 := h1 + b

    h2 := h2 + c

    h3 := h3 + d

    h4 := h4 + e

digest = hash = h0 append h1 append h2 append h3 append h4 (expressed as big-endian)

SHA-256

//Note: All variables are unsigned 32 bits and wrap modulo 2^32 when calculating

//Initialize variables:

h0 := 0x6a09e667  //232 times the square root of the first 8 primes 2..19

h1 := 0xbb67ae85

h2 := 0x3c6ef372

h3 := 0xa54ff53a

h4 := 0x510e527f

h5 := 0x9b05688c

h6 := 0x1f83d9ab

h7 := 0x5be0cd19

//Initialize table of round constants:

k(0..63) :=        //232 times the cube root of the first 64 primes 2..311

  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,

  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,

  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,

  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,

  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,

  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,

  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,

  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2

//Pre-processing:

append a single "1" bit to  message

append "0" bits until message length ? 448 ? -64 (mod 512)

append length of message (before pre-processing), in bits as 64-bit big-endian integer to message

//Process the message in successive 512-bit chunks:

break message into 512-bit chunks

for each chunk

    break chunk into sixteen 32-bit big-endian words w(i), 0 ? i ? 15

    //Extend the sixteen 32-bit words into sixty-four 32-bit words:

    for i from 16 to 63

        s0 := (w(i-15) rightrotate 7) xor (w(i-15) rightrotate 1b) xor (w(i-15) rightshift 3)

        s1 := (w(i-2) rightrotate 17) xor (w(i-2) rightrotate 19) xor (w(i-2) rightshift 10)

        w(i) := w(i-16) + s0 + w(i-7) + s1

    //Initialize hash value for this chunk:

    a := h0

    b := h1

    c := h2

    d := h3

    e := h4

    f := h5

    g := h6

    h := h7

    //Main loop:

    for i from 0 to 63

        s0 := (a rightrotate 2) xor (a rightrotate 13) xor (a rightrotate 22)

        maj := (a and xor (a and c) xor (b and c)

        t2 := s0 + maj

        s1 := (e rightrotate 6) xor (e rightrotate 11) xor (e rightrotate 25)

        ch := (e and f) xor ((not e) and g)

        t1 := h + s1 + ch + k(i) + w(i)

        h := g

        g := f

        f := e

        e := d + t1

        d := c

        c := b

        b := a

        a := t1 + t2

    //Add this chunk's hash to result so far:

    h0 := h0 + a

    h1 := h1 + b

    h2 := h2 + c

    h3 := h3 + d

    h4 := h4 + e

    h5 := h5 + f

    h6 := h6 + g

    h7 := h7 + h

RSA

http://en.wikipedia.org/wiki/RSA