1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/vlib/crypto/sha1/sha1block_generic.v

125 lines
2.5 KiB
V
Raw Normal View History

2019-07-16 15:20:51 +03:00
// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
2019-07-17 12:00:15 +03:00
// This is the generic version with no architecture optimizations.
// In its own file so that an architecture
// optimized verision can be substituted
2019-07-16 15:20:51 +03:00
2019-07-15 18:49:01 +03:00
module sha1
import math.bits
const (
2019-10-24 14:48:20 +03:00
_k0 = 0x5A827999
_k1 = 0x6ED9EBA1
_k2 = 0x8F1BBCDC
_k3 = 0xCA62C1D6
2019-07-15 18:49:01 +03:00
)
2019-08-07 14:37:07 +03:00
fn block_generic(dig mut Digest, p_ []byte) {
mut p := p_
mut w := [u32(0)].repeat(16)
2019-07-15 18:49:01 +03:00
mut h0 := dig.h[0]
mut h1 := dig.h[1]
mut h2 := dig.h[2]
mut h3 := dig.h[3]
mut h4 := dig.h[4]
2019-10-24 14:48:20 +03:00
for p.len >= chunk {
2019-07-15 18:49:01 +03:00
// Can interlace the computation of w with the
// rounds below if needed for speed.
for i := 0; i < 16; i++ {
j := i * 4
w[i] = u32(p[j]<<24) | u32(p[j+1]<<16) | u32(p[j+2]<<8) | u32(p[j+3])
2019-07-15 18:49:01 +03:00
}
mut a := h0
mut b := h1
mut c := h2
mut d := h3
mut e := h4
// Each of the four 20-iteration rounds
// differs only in the computation of f and
2019-10-24 14:48:20 +03:00
// the choice of K (_k0, _k1, etc).
2019-07-15 18:49:01 +03:00
mut i := 0
for i < 16 {
f := b&c | (~b)&d
2019-10-24 14:48:20 +03:00
t := bits.rotate_left_32(a, 5) + f + e + w[i&0xf] + u32(_k0)
2019-07-15 18:49:01 +03:00
e = d
d = c
c = bits.rotate_left_32(b, 30)
b = a
a = t
i++
}
for i < 20 {
tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf]
w[i&0xf] = tmp<<1 | u32(tmp>>(32-1))
2019-07-15 18:49:01 +03:00
f := b&c | (~b)&d
2019-10-24 14:48:20 +03:00
t := bits.rotate_left_32(a, 5) + f + e + w[i&0xf] + u32(_k0)
2019-07-15 18:49:01 +03:00
e = d
d = c
c = bits.rotate_left_32(b, 30)
b = a
a = t
i++
}
for i < 40 {
tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf]
w[i&0xf] = tmp<<1 | u32(tmp>>(32-1))
2019-07-15 18:49:01 +03:00
f := b ^ c ^ d
2019-10-24 14:48:20 +03:00
t := bits.rotate_left_32(a, 5) + f + e + w[i&0xf] + u32(_k1)
2019-07-15 18:49:01 +03:00
e = d
d = c
c = bits.rotate_left_32(b, 30)
b = a
a = t
i++
}
for i < 60 {
tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf]
w[i&0xf] = tmp<<1 | u32(tmp>>(32-1))
2019-07-15 18:49:01 +03:00
f := ((b | c) & d) | (b & c)
2019-10-24 14:48:20 +03:00
t := bits.rotate_left_32(a, 5) + f + e + w[i&0xf] + u32(_k2)
2019-07-15 18:49:01 +03:00
e = d
d = c
c = bits.rotate_left_32(b, 30)
b = a
a = t
i++
}
for i < 80 {
tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf]
w[i&0xf] = tmp<<1 | u32(tmp>>(32-1))
2019-07-15 18:49:01 +03:00
f := b ^ c ^ d
2019-10-24 14:48:20 +03:00
t := bits.rotate_left_32(a, 5) + f + e + w[i&0xf] + u32(_k3)
2019-07-15 18:49:01 +03:00
e = d
d = c
c = bits.rotate_left_32(b, 30)
b = a
a = t
i++
}
h0 += a
h1 += b
h2 += c
h3 += d
h4 += e
2019-10-24 14:48:20 +03:00
if chunk >= p.len {
2019-07-15 18:49:01 +03:00
p = []byte
} else {
2019-10-24 14:48:20 +03:00
p = p.right(chunk)
2019-07-15 18:49:01 +03:00
}
}
dig.h[0] = h0
dig.h[1] = h1
dig.h[2] = h2
dig.h[3] = h3
dig.h[4] = h4
}