vieter-v
/
v
2
0
Fork 0
Code Issues Pull Requests Releases Activity

lower/snake case consts & enums

pull/2532/head
joe-conigliaro 2019-10-24 22:48:20 +11:00 committed by Alexander Medvednikov
parent fe17dd9a7e
commit 580abe0de4
20 changed files with 301 additions and 308 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
vlib/compiler/tests/module_test.v
View File

@ -11,8 +11,8 @@ import (
fn test_import() { fn test_import() {
assert os.O_RDONLY == os.O_RDONLY && assert os.O_RDONLY == os.O_RDONLY &&
t.month_days[0] == t.month_days[0] && t.month_days[0] == t.month_days[0] &&
s2.Size == s2.Size && s2.size == s2.size &&
math.pi == math.pi && math.pi == math.pi &&
l.INFO == l.INFO && l.INFO == l.INFO &&
s5.Size == s5.Size s5.size == s5.size
} }

18
vlib/crypto/aes/aes.v
View File

@ -13,7 +13,7 @@ import (
const ( const (
// The AES block size in bytes. // The AES block size in bytes.
BlockSize = 16 block_size = 16
) )
// A cipher is an instance of AES encryption using a particular key. // A cipher is an instance of AES encryption using a particular key.
@ -39,17 +39,17 @@ pub fn new_cipher(key []byte) AesCipher {
return new_cipher_generic(key) return new_cipher_generic(key)
} }
pub fn (c &AesCipher) block_size() int { return BlockSize } pub fn (c &AesCipher) block_size() int { return block_size }
pub fn (c &AesCipher) encrypt(dst, src []byte) { pub fn (c &AesCipher) encrypt(dst, src []byte) {
if src.len < BlockSize { if src.len < block_size {
panic('crypto.aes: input not full block') panic('crypto.aes: input not full block')
} }
if dst.len < BlockSize { if dst.len < block_size {
panic('crypto.aes: output not full block') panic('crypto.aes: output not full block')
} }
// if subtle.inexact_overlap(dst[:BlockSize], src[:BlockSize]) { // if subtle.inexact_overlap(dst[:block_size], src[:block_size]) {
if subtle.inexact_overlap(dst.left(BlockSize), src.left(BlockSize)) { if subtle.inexact_overlap(dst.left(block_size), src.left(block_size)) {
panic('crypto.aes: invalid buffer overlap') panic('crypto.aes: invalid buffer overlap')
} }
// for now use generic version // for now use generic version
@ -57,13 +57,13 @@ pub fn (c &AesCipher) encrypt(dst, src []byte) {
} }
pub fn (c &AesCipher) decrypt(dst, src []byte) { pub fn (c &AesCipher) decrypt(dst, src []byte) {
if src.len < BlockSize { if src.len < block_size {
panic('crypto.aes: input not full block') panic('crypto.aes: input not full block')
} }
if dst.len < BlockSize { if dst.len < block_size {
panic('crypto.aes: output not full block') panic('crypto.aes: output not full block')
} }
if subtle.inexact_overlap(dst.left(BlockSize), src.left(BlockSize)) { if subtle.inexact_overlap(dst.left(block_size), src.left(block_size)) {
panic('crypto.aes: invalid buffer overlap') panic('crypto.aes: invalid buffer overlap')
} }
// for now use generic version // for now use generic version

8
vlib/crypto/aes/aes_test.v
View File

@ -11,13 +11,13 @@ fn test_crypto_aes() {
block := aes.new_cipher(key) block := aes.new_cipher(key)
// The IV needs to be unique, but not secure. Therefore it's common to // The IV needs to be unique, but not secure. Therefore it's common to
// include it at the beginning of the ciphertext. // include it at the beginning of the ciphertext.
if ciphertext.len < aes.BlockSize { if ciphertext.len < aes.block_size {
panic('ciphertext too short') panic('ciphertext too short')
} }
iv := ciphertext.left(aes.BlockSize) iv := ciphertext.left(aes.block_size)
ciphertext = ciphertext.right(aes.BlockSize) ciphertext = ciphertext.right(aes.block_size)
// CBC mode always works in whole blocks. // CBC mode always works in whole blocks.
if ciphertext.len%aes.BlockSize != 0 { if ciphertext.len%aes.block_size != 0 {
panic('ciphertext is not a multiple of the block size') panic('ciphertext is not a multiple of the block size')
} }
mut mode := aes.new_cbc(block, iv) mut mode := aes.new_cbc(block, iv)

46
vlib/crypto/aes/block_generic.v
View File

@ -64,10 +64,10 @@ fn encrypt_block_generic(xk []u32, dst, src []byte) {
mut t2 := u32(0) mut t2 := u32(0)
mut t3 := u32(0) mut t3 := u32(0)
for r := 0; r < nr; r++ { for r := 0; r < nr; r++ {
t0 = xk[k+0] ^ Te0[byte(s0>>24)] ^ Te1[byte(s1>>16)] ^ Te2[byte(s2>>8)] ^ u32(Te3[byte(s3)]) t0 = xk[k+0] ^ te0[byte(s0>>24)] ^ te1[byte(s1>>16)] ^ te2[byte(s2>>8)] ^ u32(te3[byte(s3)])
t1 = xk[k+1] ^ Te0[byte(s1>>24)] ^ Te1[byte(s2>>16)] ^ Te2[byte(s3>>8)] ^ u32(Te3[byte(s0)]) t1 = xk[k+1] ^ te0[byte(s1>>24)] ^ te1[byte(s2>>16)] ^ te2[byte(s3>>8)] ^ u32(te3[byte(s0)])
t2 = xk[k+2] ^ Te0[byte(s2>>24)] ^ Te1[byte(s3>>16)] ^ Te2[byte(s0>>8)] ^ u32(Te3[byte(s1)]) t2 = xk[k+2] ^ te0[byte(s2>>24)] ^ te1[byte(s3>>16)] ^ te2[byte(s0>>8)] ^ u32(te3[byte(s1)])
t3 = xk[k+3] ^ Te0[byte(s3>>24)] ^ Te1[byte(s0>>16)] ^ Te2[byte(s1>>8)] ^ u32(Te3[byte(s2)]) t3 = xk[k+3] ^ te0[byte(s3>>24)] ^ te1[byte(s0>>16)] ^ te2[byte(s1>>8)] ^ u32(te3[byte(s2)])
k += 4 k += 4
s0 = t0 s0 = t0
s1 = t1 s1 = t1
@ -76,10 +76,10 @@ fn encrypt_block_generic(xk []u32, dst, src []byte) {
} }
// Last round uses s-box directly and XORs to produce output. // Last round uses s-box directly and XORs to produce output.
s0 = SBox0[t0>>24]<<24 | SBox0[t1>>16&0xff]<<16 | u32(SBox0[t2>>8&0xff]<<8) | SBox0[t3&u32(0xff)] s0 = s_box0[t0>>24]<<24 | s_box0[t1>>16&0xff]<<16 | u32(s_box0[t2>>8&0xff]<<8) | s_box0[t3&u32(0xff)]
s1 = SBox0[t1>>24]<<24 | SBox0[t2>>16&0xff]<<16 | u32(SBox0[t3>>8&0xff]<<8) | SBox0[t0&u32(0xff)] s1 = s_box0[t1>>24]<<24 | s_box0[t2>>16&0xff]<<16 | u32(s_box0[t3>>8&0xff]<<8) | s_box0[t0&u32(0xff)]
s2 = SBox0[t2>>24]<<24 | SBox0[t3>>16&0xff]<<16 | u32(SBox0[t0>>8&0xff]<<8) | SBox0[t1&u32(0xff)] s2 = s_box0[t2>>24]<<24 | s_box0[t3>>16&0xff]<<16 | u32(s_box0[t0>>8&0xff]<<8) | s_box0[t1&u32(0xff)]
s3 = SBox0[t3>>24]<<24 | SBox0[t0>>16&0xff]<<16 | u32(SBox0[t1>>8&0xff]<<8) | SBox0[t2&u32(0xff)] s3 = s_box0[t3>>24]<<24 | s_box0[t0>>16&0xff]<<16 | u32(s_box0[t1>>8&0xff]<<8) | s_box0[t2&u32(0xff)]
s0 ^= xk[k+0] s0 ^= xk[k+0]
s1 ^= xk[k+1] s1 ^= xk[k+1]
@ -116,10 +116,10 @@ fn decrypt_block_generic(xk []u32, dst, src []byte) {
mut t2 := u32(0) mut t2 := u32(0)
mut t3 := u32(0) mut t3 := u32(0)
for r := 0; r < nr; r++ { for r := 0; r < nr; r++ {
t0 = xk[k+0] ^ Td0[byte(s0>>24)] ^ Td1[byte(s3>>16)] ^ Td2[byte(s2>>8)] ^ u32(Td3[byte(s1)]) t0 = xk[k+0] ^ td0[byte(s0>>24)] ^ td1[byte(s3>>16)] ^ td2[byte(s2>>8)] ^ u32(td3[byte(s1)])
t1 = xk[k+1] ^ Td0[byte(s1>>24)] ^ Td1[byte(s0>>16)] ^ Td2[byte(s3>>8)] ^ u32(Td3[byte(s2)]) t1 = xk[k+1] ^ td0[byte(s1>>24)] ^ td1[byte(s0>>16)] ^ td2[byte(s3>>8)] ^ u32(td3[byte(s2)])
t2 = xk[k+2] ^ Td0[byte(s2>>24)] ^ Td1[byte(s1>>16)] ^ Td2[byte(s0>>8)] ^ u32(Td3[byte(s3)]) t2 = xk[k+2] ^ td0[byte(s2>>24)] ^ td1[byte(s1>>16)] ^ td2[byte(s0>>8)] ^ u32(td3[byte(s3)])
t3 = xk[k+3] ^ Td0[byte(s3>>24)] ^ Td1[byte(s2>>16)] ^ Td2[byte(s1>>8)] ^ u32(Td3[byte(s0)]) t3 = xk[k+3] ^ td0[byte(s3>>24)] ^ td1[byte(s2>>16)] ^ td2[byte(s1>>8)] ^ u32(td3[byte(s0)])
k += 4 k += 4
s0 = t0 s0 = t0
s1 = t1 s1 = t1
@ -128,10 +128,10 @@ fn decrypt_block_generic(xk []u32, dst, src []byte) {
} }
// Last round uses s-box directly and XORs to produce output. // Last round uses s-box directly and XORs to produce output.
s0 = u32(SBox1[t0>>24])<<24 | u32(SBox1[t3>>16&0xff])<<16 | u32(SBox1[t2>>8&0xff]<<8) | u32(SBox1[t1&u32(0xff)]) s0 = u32(s_box1[t0>>24])<<24 | u32(s_box1[t3>>16&0xff])<<16 | u32(s_box1[t2>>8&0xff]<<8) | u32(s_box1[t1&u32(0xff)])
s1 = u32(SBox1[t1>>24])<<24 | u32(SBox1[t0>>16&0xff])<<16 | u32(SBox1[t3>>8&0xff]<<8) | u32(SBox1[t2&u32(0xff)]) s1 = u32(s_box1[t1>>24])<<24 | u32(s_box1[t0>>16&0xff])<<16 | u32(s_box1[t3>>8&0xff]<<8) | u32(s_box1[t2&u32(0xff)])
s2 = u32(SBox1[t2>>24])<<24 | u32(SBox1[t1>>16&0xff])<<16 | u32(SBox1[t0>>8&0xff]<<8) | u32(SBox1[t3&u32(0xff)]) s2 = u32(s_box1[t2>>24])<<24 | u32(s_box1[t1>>16&0xff])<<16 | u32(s_box1[t0>>8&0xff]<<8) | u32(s_box1[t3&u32(0xff)])
s3 = u32(SBox1[t3>>24])<<24 | u32(SBox1[t2>>16&0xff])<<16 | u32(SBox1[t1>>8&0xff]<<8) | u32(SBox1[t0&u32(0xff)]) s3 = u32(s_box1[t3>>24])<<24 | u32(s_box1[t2>>16&0xff])<<16 | u32(s_box1[t1>>8&0xff]<<8) | u32(s_box1[t0&u32(0xff)])
s0 ^= xk[k+0] s0 ^= xk[k+0]
s1 ^= xk[k+1] s1 ^= xk[k+1]
@ -145,12 +145,12 @@ fn decrypt_block_generic(xk []u32, dst, src []byte) {
binary.big_endian_put_u32(mut dst.slice(12, 16), s3) binary.big_endian_put_u32(mut dst.slice(12, 16), s3)
} }
// Apply SBox0 to each byte in w. // Apply s_box0 to each byte in w.
fn subw(w u32) u32 { fn subw(w u32) u32 {
return u32(SBox0[w>>24])<<24 | return u32(s_box0[w>>24])<<24 |
u32(SBox0[w>>16&0xff]<<16) | u32(s_box0[w>>16&0xff]<<16) |
u32(SBox0[w>>8&0xff]<<8) | u32(s_box0[w>>8&0xff]<<8) |
u32(SBox0[w&u32(0xff)]) u32(s_box0[w&u32(0xff)])
} }
// Rotate // Rotate
@ -172,7 +172,7 @@ fn expand_key_generic(key []byte, enc mut []u32, dec mut []u32) {
for i < enc.len { for i < enc.len {
mut t := enc[i-1] mut t := enc[i-1]
if i%nk == 0 { if i%nk == 0 {
t = subw(rotw(t)) ^ u32(PowX[i/nk-1]) << 24 t = subw(rotw(t)) ^ u32(pow_x[i/nk-1]) << 24
} else if nk > 6 && i%nk == 4 { } else if nk > 6 && i%nk == 4 {
t = subw(t) t = subw(t)
} }
@ -192,7 +192,7 @@ fn expand_key_generic(key []byte, enc mut []u32, dec mut []u32) {
for j := 0; j < 4; j++ { for j := 0; j < 4; j++ {
mut x := enc[ei+j] mut x := enc[ei+j]
if i > 0 && i+4 < n { if i > 0 && i+4 < n {
x = Td0[SBox0[x>>24]] ^ Td1[SBox0[x>>16&0xff]] ^ Td2[SBox0[x>>8&0xff]] ^ Td3[SBox0[x&u32(0xff)]] x = td0[s_box0[x>>24]] ^ td1[s_box0[x>>16&0xff]] ^ td2[s_box0[x>>8&0xff]] ^ td3[s_box0[x&u32(0xff)]]
} }
dec[i+j] = x dec[i+j] = x
} }

24
vlib/crypto/aes/const.v
View File

@ -23,12 +23,12 @@ module aes
// Reducing mod poly corresponds to binary xor with poly every // Reducing mod poly corresponds to binary xor with poly every
// time a 0x100 bit appears. // time a 0x100 bit appears.
const ( const (
Poly = int(1<<8) | int(1<<4) | int(1<<3) | int(1<<1) | int(1<<0) // x⁸ + x⁴ + x³ + x + 1 poly = int(1<<8) | int(1<<4) | int(1<<3) | int(1<<1) | int(1<<0) // x⁸ + x⁴ + x³ + x + 1
) )
// Powers of x mod poly in GF(2). // Powers of x mod poly in GF(2).
const ( const (
PowX = [ pow_x = [
byte(0x01), byte(0x01),
0x02, 0x02,
0x04, 0x04,
@ -50,7 +50,7 @@ const (
// FIPS-197 Figure 7. S-box substitution values in hexadecimal format. // FIPS-197 Figure 7. S-box substitution values in hexadecimal format.
const ( const (
SBox0 = [ s_box0 = [
byte(0x63), 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, byte(0x63), 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
@ -72,7 +72,7 @@ const (
// FIPS-197 Figure 14. Inverse S-box substitution values in hexadecimal format. // FIPS-197 Figure 14. Inverse S-box substitution values in hexadecimal format.
const ( const (
SBox1 = [ s_box1 = [
byte(0x52), 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, byte(0x52), 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
@ -95,7 +95,7 @@ const (
// Lookup tables for encryption. // Lookup tables for encryption.
const ( const (
Te0 = [ te0 = [
0xc66363a5, 0xf87c7c84, 0xee777799, 0xf67b7b8d, 0xfff2f20d, 0xd66b6bbd, 0xde6f6fb1, 0x91c5c554, 0xc66363a5, 0xf87c7c84, 0xee777799, 0xf67b7b8d, 0xfff2f20d, 0xd66b6bbd, 0xde6f6fb1, 0x91c5c554,
0x60303050, 0x02010103, 0xce6767a9, 0x562b2b7d, 0xe7fefe19, 0xb5d7d762, 0x4dababe6, 0xec76769a, 0x60303050, 0x02010103, 0xce6767a9, 0x562b2b7d, 0xe7fefe19, 0xb5d7d762, 0x4dababe6, 0xec76769a,
0x8fcaca45, 0x1f82829d, 0x89c9c940, 0xfa7d7d87, 0xeffafa15, 0xb25959eb, 0x8e4747c9, 0xfbf0f00b, 0x8fcaca45, 0x1f82829d, 0x89c9c940, 0xfa7d7d87, 0xeffafa15, 0xb25959eb, 0x8e4747c9, 0xfbf0f00b,
@ -129,7 +129,7 @@ const (
0x038c8c8f, 0x59a1a1f8, 0x09898980, 0x1a0d0d17, 0x65bfbfda, 0xd7e6e631, 0x844242c6, 0xd06868b8, 0x038c8c8f, 0x59a1a1f8, 0x09898980, 0x1a0d0d17, 0x65bfbfda, 0xd7e6e631, 0x844242c6, 0xd06868b8,
0x824141c3, 0x299999b0, 0x5a2d2d77, 0x1e0f0f11, 0x7bb0b0cb, 0xa85454fc, 0x6dbbbbd6, 0x2c16163a, 0x824141c3, 0x299999b0, 0x5a2d2d77, 0x1e0f0f11, 0x7bb0b0cb, 0xa85454fc, 0x6dbbbbd6, 0x2c16163a,
] ]
Te1 = [ te1 = [
0xa5c66363, 0x84f87c7c, 0x99ee7777, 0x8df67b7b, 0x0dfff2f2, 0xbdd66b6b, 0xb1de6f6f, 0x5491c5c5, 0xa5c66363, 0x84f87c7c, 0x99ee7777, 0x8df67b7b, 0x0dfff2f2, 0xbdd66b6b, 0xb1de6f6f, 0x5491c5c5,
0x50603030, 0x03020101, 0xa9ce6767, 0x7d562b2b, 0x19e7fefe, 0x62b5d7d7, 0xe64dabab, 0x9aec7676, 0x50603030, 0x03020101, 0xa9ce6767, 0x7d562b2b, 0x19e7fefe, 0x62b5d7d7, 0xe64dabab, 0x9aec7676,
0x458fcaca, 0x9d1f8282, 0x4089c9c9, 0x87fa7d7d, 0x15effafa, 0xebb25959, 0xc98e4747, 0x0bfbf0f0, 0x458fcaca, 0x9d1f8282, 0x4089c9c9, 0x87fa7d7d, 0x15effafa, 0xebb25959, 0xc98e4747, 0x0bfbf0f0,
@ -163,7 +163,7 @@ const (
0x8f038c8c, 0xf859a1a1, 0x80098989, 0x171a0d0d, 0xda65bfbf, 0x31d7e6e6, 0xc6844242, 0xb8d06868, 0x8f038c8c, 0xf859a1a1, 0x80098989, 0x171a0d0d, 0xda65bfbf, 0x31d7e6e6, 0xc6844242, 0xb8d06868,
0xc3824141, 0xb0299999, 0x775a2d2d, 0x111e0f0f, 0xcb7bb0b0, 0xfca85454, 0xd66dbbbb, 0x3a2c1616, 0xc3824141, 0xb0299999, 0x775a2d2d, 0x111e0f0f, 0xcb7bb0b0, 0xfca85454, 0xd66dbbbb, 0x3a2c1616,
] ]
Te2 = [ te2 = [
0x63a5c663, 0x7c84f87c, 0x7799ee77, 0x7b8df67b, 0xf20dfff2, 0x6bbdd66b, 0x6fb1de6f, 0xc55491c5, 0x63a5c663, 0x7c84f87c, 0x7799ee77, 0x7b8df67b, 0xf20dfff2, 0x6bbdd66b, 0x6fb1de6f, 0xc55491c5,
0x30506030, 0x01030201, 0x67a9ce67, 0x2b7d562b, 0xfe19e7fe, 0xd762b5d7, 0xabe64dab, 0x769aec76, 0x30506030, 0x01030201, 0x67a9ce67, 0x2b7d562b, 0xfe19e7fe, 0xd762b5d7, 0xabe64dab, 0x769aec76,
0xca458fca, 0x829d1f82, 0xc94089c9, 0x7d87fa7d, 0xfa15effa, 0x59ebb259, 0x47c98e47, 0xf00bfbf0, 0xca458fca, 0x829d1f82, 0xc94089c9, 0x7d87fa7d, 0xfa15effa, 0x59ebb259, 0x47c98e47, 0xf00bfbf0,
@ -197,7 +197,7 @@ const (
0x8c8f038c, 0xa1f859a1, 0x89800989, 0x0d171a0d, 0xbfda65bf, 0xe631d7e6, 0x42c68442, 0x68b8d068, 0x8c8f038c, 0xa1f859a1, 0x89800989, 0x0d171a0d, 0xbfda65bf, 0xe631d7e6, 0x42c68442, 0x68b8d068,
0x41c38241, 0x99b02999, 0x2d775a2d, 0x0f111e0f, 0xb0cb7bb0, 0x54fca854, 0xbbd66dbb, 0x163a2c16, 0x41c38241, 0x99b02999, 0x2d775a2d, 0x0f111e0f, 0xb0cb7bb0, 0x54fca854, 0xbbd66dbb, 0x163a2c16,
] ]
Te3 = [ te3 = [
0x6363a5c6, 0x7c7c84f8, 0x777799ee, 0x7b7b8df6, 0xf2f20dff, 0x6b6bbdd6, 0x6f6fb1de, 0xc5c55491, 0x6363a5c6, 0x7c7c84f8, 0x777799ee, 0x7b7b8df6, 0xf2f20dff, 0x6b6bbdd6, 0x6f6fb1de, 0xc5c55491,
0x30305060, 0x01010302, 0x6767a9ce, 0x2b2b7d56, 0xfefe19e7, 0xd7d762b5, 0xababe64d, 0x76769aec, 0x30305060, 0x01010302, 0x6767a9ce, 0x2b2b7d56, 0xfefe19e7, 0xd7d762b5, 0xababe64d, 0x76769aec,
0xcaca458f, 0x82829d1f, 0xc9c94089, 0x7d7d87fa, 0xfafa15ef, 0x5959ebb2, 0x4747c98e, 0xf0f00bfb, 0xcaca458f, 0x82829d1f, 0xc9c94089, 0x7d7d87fa, 0xfafa15ef, 0x5959ebb2, 0x4747c98e, 0xf0f00bfb,
@ -235,7 +235,7 @@ const (
// Lookup tables for decryption. // Lookup tables for decryption.
const ( const (
Td0 = [ td0 = [
0x51f4a750, 0x7e416553, 0x1a17a4c3, 0x3a275e96, 0x3bab6bcb, 0x1f9d45f1, 0xacfa58ab, 0x4be30393, 0x51f4a750, 0x7e416553, 0x1a17a4c3, 0x3a275e96, 0x3bab6bcb, 0x1f9d45f1, 0xacfa58ab, 0x4be30393,
0x2030fa55, 0xad766df6, 0x88cc7691, 0xf5024c25, 0x4fe5d7fc, 0xc52acbd7, 0x26354480, 0xb562a38f, 0x2030fa55, 0xad766df6, 0x88cc7691, 0xf5024c25, 0x4fe5d7fc, 0xc52acbd7, 0x26354480, 0xb562a38f,
0xdeb15a49, 0x25ba1b67, 0x45ea0e98, 0x5dfec0e1, 0xc32f7502, 0x814cf012, 0x8d4697a3, 0x6bd3f9c6, 0xdeb15a49, 0x25ba1b67, 0x45ea0e98, 0x5dfec0e1, 0xc32f7502, 0x814cf012, 0x8d4697a3, 0x6bd3f9c6,
@ -269,7 +269,7 @@ const (
0xcaaff381, 0xb968c43e, 0x3824342c, 0xc2a3405f, 0x161dc372, 0xbce2250c, 0x283c498b, 0xff0d9541, 0xcaaff381, 0xb968c43e, 0x3824342c, 0xc2a3405f, 0x161dc372, 0xbce2250c, 0x283c498b, 0xff0d9541,
0x39a80171, 0x080cb3de, 0xd8b4e49c, 0x6456c190, 0x7bcb8461, 0xd532b670, 0x486c5c74, 0xd0b85742, 0x39a80171, 0x080cb3de, 0xd8b4e49c, 0x6456c190, 0x7bcb8461, 0xd532b670, 0x486c5c74, 0xd0b85742,
] ]
Td1 = [ td1 = [
0x5051f4a7, 0x537e4165, 0xc31a17a4, 0x963a275e, 0xcb3bab6b, 0xf11f9d45, 0xabacfa58, 0x934be303, 0x5051f4a7, 0x537e4165, 0xc31a17a4, 0x963a275e, 0xcb3bab6b, 0xf11f9d45, 0xabacfa58, 0x934be303,
0x552030fa, 0xf6ad766d, 0x9188cc76, 0x25f5024c, 0xfc4fe5d7, 0xd7c52acb, 0x80263544, 0x8fb562a3, 0x552030fa, 0xf6ad766d, 0x9188cc76, 0x25f5024c, 0xfc4fe5d7, 0xd7c52acb, 0x80263544, 0x8fb562a3,
0x49deb15a, 0x6725ba1b, 0x9845ea0e, 0xe15dfec0, 0x02c32f75, 0x12814cf0, 0xa38d4697, 0xc66bd3f9, 0x49deb15a, 0x6725ba1b, 0x9845ea0e, 0xe15dfec0, 0x02c32f75, 0x12814cf0, 0xa38d4697, 0xc66bd3f9,
@ -303,7 +303,7 @@ const (
0x81caaff3, 0x3eb968c4, 0x2c382434, 0x5fc2a340, 0x72161dc3, 0x0cbce225, 0x8b283c49, 0x41ff0d95, 0x81caaff3, 0x3eb968c4, 0x2c382434, 0x5fc2a340, 0x72161dc3, 0x0cbce225, 0x8b283c49, 0x41ff0d95,
0x7139a801, 0xde080cb3, 0x9cd8b4e4, 0x906456c1, 0x617bcb84, 0x70d532b6, 0x74486c5c, 0x42d0b857, 0x7139a801, 0xde080cb3, 0x9cd8b4e4, 0x906456c1, 0x617bcb84, 0x70d532b6, 0x74486c5c, 0x42d0b857,
] ]
Td2 = [ td2 = [
0xa75051f4, 0x65537e41, 0xa4c31a17, 0x5e963a27, 0x6bcb3bab, 0x45f11f9d, 0x58abacfa, 0x03934be3, 0xa75051f4, 0x65537e41, 0xa4c31a17, 0x5e963a27, 0x6bcb3bab, 0x45f11f9d, 0x58abacfa, 0x03934be3,
0xfa552030, 0x6df6ad76, 0x769188cc, 0x4c25f502, 0xd7fc4fe5, 0xcbd7c52a, 0x44802635, 0xa38fb562, 0xfa552030, 0x6df6ad76, 0x769188cc, 0x4c25f502, 0xd7fc4fe5, 0xcbd7c52a, 0x44802635, 0xa38fb562,
0x5a49deb1, 0x1b6725ba, 0x0e9845ea, 0xc0e15dfe, 0x7502c32f, 0xf012814c, 0x97a38d46, 0xf9c66bd3, 0x5a49deb1, 0x1b6725ba, 0x0e9845ea, 0xc0e15dfe, 0x7502c32f, 0xf012814c, 0x97a38d46, 0xf9c66bd3,
@ -337,7 +337,7 @@ const (
0xf381caaf, 0xc43eb968, 0x342c3824, 0x405fc2a3, 0xc372161d, 0x250cbce2, 0x498b283c, 0x9541ff0d, 0xf381caaf, 0xc43eb968, 0x342c3824, 0x405fc2a3, 0xc372161d, 0x250cbce2, 0x498b283c, 0x9541ff0d,
0x017139a8, 0xb3de080c, 0xe49cd8b4, 0xc1906456, 0x84617bcb, 0xb670d532, 0x5c74486c, 0x5742d0b8, 0x017139a8, 0xb3de080c, 0xe49cd8b4, 0xc1906456, 0x84617bcb, 0xb670d532, 0x5c74486c, 0x5742d0b8,
] ]
Td3 = [ td3 = [
0xf4a75051, 0x4165537e, 0x17a4c31a, 0x275e963a, 0xab6bcb3b, 0x9d45f11f, 0xfa58abac, 0xe303934b, 0xf4a75051, 0x4165537e, 0x17a4c31a, 0x275e963a, 0xab6bcb3b, 0x9d45f11f, 0xfa58abac, 0xe303934b,
0x30fa5520, 0x766df6ad, 0xcc769188, 0x024c25f5, 0xe5d7fc4f, 0x2acbd7c5, 0x35448026, 0x62a38fb5, 0x30fa5520, 0x766df6ad, 0xcc769188, 0x024c25f5, 0xe5d7fc4f, 0x2acbd7c5, 0x35448026, 0x62a38fb5,
0xb15a49de, 0xba1b6725, 0xea0e9845, 0xfec0e15d, 0x2f7502c3, 0x4cf01281, 0x4697a38d, 0xd3f9c66b, 0xb15a49de, 0xba1b6725, 0xea0e9845, 0xfec0e15d, 0x2f7502c3, 0x4cf01281, 0x4697a38d, 0xd3f9c66b,

38
vlib/crypto/crypto.v
View File

@ -1,23 +1,23 @@
module crypto module crypto
pub enum Hash { pub enum Hash {
MD4 md4
MD5 md5
SHA1 sha1
SHA224 sha224
SHA256 sha256
SHA384 sha384
SHA512 sha512
MD5SHA1 md5sha1
RIPEMD160 ripemd160
SHA3_224 sha3_224
SHA3_256 sha3_256
SHA3_384 sha3_384
SHA3_512 sha3_512
SHA512_224 sha512_224
SHA512_256 sha512_256
BLAKE2s_256 blake2s_256
BLAKE2b_256 blake2b_256
BLAKE2b_384 blake2b_384
BLAKE2b_512 blake2b_512
} }

34
vlib/crypto/md5/md5.v
View File

@ -16,16 +16,16 @@ import encoding.binary
const ( const (
// The size of an MD5 checksum in bytes. // The size of an MD5 checksum in bytes.
Size = 16 size = 16
// The blocksize of MD5 in bytes. // The blocksize of MD5 in bytes.
BlockSize = 64 block_size = 64
) )
const ( const (
Init0 = 0x67452301 init0 = 0x67452301
Init1 = 0xEFCDAB89 init1 = 0xEFCDAB89
Init2 = 0x98BADCFE init2 = 0x98BADCFE
Init3 = 0x10325476 init3 = 0x10325476
) )
// Digest represents the partial evaluation of a checksum. // Digest represents the partial evaluation of a checksum.
@ -39,11 +39,11 @@ mut:
fn (d mut Digest) reset() { fn (d mut Digest) reset() {
d.s = [u32(0)].repeat(4) d.s = [u32(0)].repeat(4)
d.x = [byte(0)].repeat(BlockSize) d.x = [byte(0)].repeat(block_size)
d.s[0] = u32(Init0) d.s[0] = u32(init0)
d.s[1] = u32(Init1) d.s[1] = u32(init1)
d.s[2] = u32(Init2) d.s[2] = u32(init2)
d.s[3] = u32(Init3) d.s[3] = u32(init3)
d.nx = 0 d.nx = 0
d.len = 0 d.len = 0
} }
@ -62,7 +62,7 @@ pub fn (d mut Digest) write(p_ []byte) ?int {
if d.nx > 0 { if d.nx > 0 {
n := copy(d.x.right(d.nx), p) n := copy(d.x.right(d.nx), p)
d.nx += n d.nx += n
if d.nx == BlockSize { if d.nx == block_size {
block(mut d, d.x) block(mut d, d.x)
d.nx = 0 d.nx = 0
} }
@ -72,8 +72,8 @@ pub fn (d mut Digest) write(p_ []byte) ?int {
p = p.right(n) p = p.right(n)
} }
} }
if p.len >= BlockSize { if p.len >= block_size {
n := p.len &~ (BlockSize - 1) n := p.len &~ (block_size - 1)
block(mut d, p.left(n)) block(mut d, p.left(n))
if n >= p.len { if n >= p.len {
p = []byte p = []byte
@ -117,7 +117,7 @@ pub fn (d mut Digest) checksum() []byte {
panic('d.nx != 0') panic('d.nx != 0')
} }
digest := [byte(0)].repeat(Size) digest := [byte(0)].repeat(size)
binary.little_endian_put_u32(mut digest, d.s[0]) binary.little_endian_put_u32(mut digest, d.s[0])
binary.little_endian_put_u32(mut digest.right(4), d.s[1]) binary.little_endian_put_u32(mut digest.right(4), d.s[1])
@ -139,8 +139,8 @@ fn block(dig mut Digest, p []byte) {
block_generic(mut dig, p) block_generic(mut dig, p)
} }
pub fn (d &Digest) size() int { return Size } pub fn (d &Digest) size() int { return size }
pub fn (d &Digest) block_size() int { return BlockSize } pub fn (d &Digest) block_size() int { return block_size }
pub fn hexhash(s string) string { return sum(s.bytes()).hex() } pub fn hexhash(s string) string { return sum(s.bytes()).hex() }

4
vlib/crypto/md5/md5block_generic.v
View File

@ -20,9 +20,9 @@ fn block_generic(dig mut Digest, p []byte) {
mut c := dig.s[2] mut c := dig.s[2]
mut d := dig.s[3] mut d := dig.s[3]
for i := 0; i <= p.len-BlockSize; i += BlockSize { for i := 0; i <= p.len-block_size; i += block_size {
mut q := p.right(i) mut q := p.right(i)
q = q.left(BlockSize) q = q.left(block_size)
// save current state // save current state
aa := a aa := a
bb := b bb := b

2
vlib/crypto/rand/rand.v
View File

@ -5,7 +5,7 @@
module rand module rand
const ( const (
ReadError = error('crypro.rand.read() error reading random bytes') read_error = error('crypro.rand.read() error reading random bytes')
) )
// NOTE: temp until we have []bytes(buff) // NOTE: temp until we have []bytes(buff)

25
vlib/crypto/rand/rand_lin.v
View File

@ -8,40 +8,33 @@ import math
#include <sys/syscall.h> #include <sys/syscall.h>
// const (
// SYS_getrandom = 278 // AArch65
// SYS_getrandom = 384 // ARM
// SYS_getrandom = 355 // x86
// SYS_getrandom = 318 // x86_64
// )
const ( const (
ReadBatchSize = 256 read_batch_size = 256
) )
pub fn read(bytes_needed int) ?[]byte { pub fn read(bytes_needed int) ?[]byte {
mut buffer := malloc(bytes_needed) mut buffer := malloc(bytes_needed)
mut bytes_read := 0 mut bytes_read := 0
// getrandom syscall wont block if requesting <= 256 bytes // getrandom syscall wont block if requesting <= 256 bytes
if bytes_needed > ReadBatchSize { if bytes_needed > read_batch_size {
no_batches := int(math.floor(f64(bytes_needed/ReadBatchSize))) no_batches := int(math.floor(f64(bytes_needed/read_batch_size)))
for i:=0; i<no_batches; i++ { for i:=0; i<no_batches; i++ {
if getrandom(ReadBatchSize, buffer+bytes_read) == -1 { if getrandom(read_batch_size, buffer+bytes_read) == -1 {
return ReadError return read_error
} }
bytes_read += ReadBatchSize bytes_read += read_batch_size
} }
} }
if getrandom(bytes_needed-bytes_read, buffer+bytes_read) == -1 { if getrandom(bytes_needed-bytes_read, buffer+bytes_read) == -1 {
return ReadError return read_error
} }
return c_array_to_bytes_tmp(bytes_needed, buffer) return c_array_to_bytes_tmp(bytes_needed, buffer)
} }
fn getrandom(bytes_needed int, buffer voidptr) int { fn getrandom(bytes_needed int, buffer voidptr) int {
if bytes_needed > ReadBatchSize { if bytes_needed > read_batch_size {
panic('getrandom() dont request more thane $ReadBatchSize bytes at once.') panic('getrandom() dont request more thane $read_batch_size bytes at once.')
} }
return C.syscall(C.SYS_getrandom, buffer, bytes_needed, 0) return C.syscall(C.SYS_getrandom, buffer, bytes_needed, 0)
} }

2
vlib/crypto/rand/rand_mac.v
View File

@ -12,7 +12,7 @@ pub fn read(bytes_needed int) ?[]byte {
mut buffer := malloc(bytes_needed) mut buffer := malloc(bytes_needed)
status := C.SecRandomCopyBytes(0, bytes_needed, buffer) status := C.SecRandomCopyBytes(0, bytes_needed, buffer)
if status != 0 { if status != 0 {
return ReadError return read_error
} }
return c_array_to_bytes_tmp(bytes_needed, buffer) return c_array_to_bytes_tmp(bytes_needed, buffer)
} }

2
vlib/crypto/rand/rand_windows.v
View File

@ -18,7 +18,7 @@ pub fn read(bytes_needed int) ?[]byte {
// use BCRYPT_USE_SYSTEM_PREFERRED_RNG because we passed null as algo // use BCRYPT_USE_SYSTEM_PREFERRED_RNG because we passed null as algo
status := C.BCryptGenRandom(0, buffer, bytes_needed, BCRYPT_USE_SYSTEM_PREFERRED_RNG) status := C.BCryptGenRandom(0, buffer, bytes_needed, BCRYPT_USE_SYSTEM_PREFERRED_RNG)
if status != STATUS_SUCCESS { if status != STATUS_SUCCESS {
return ReadError return read_error
} }
return c_array_to_bytes_tmp(bytes_needed, buffer) return c_array_to_bytes_tmp(bytes_needed, buffer)
} }

40
vlib/crypto/sha1/sha1.v
View File

@ -16,18 +16,18 @@ import encoding.binary
const( const(
// The size of a SHA-1 checksum in bytes. // The size of a SHA-1 checksum in bytes.
Size = 20 size = 20
// The blocksize of SHA-1 in bytes. // The blocksize of SHA-1 in bytes.
BlockSize = 64 block_size = 64
) )
const ( const (
Chunk = 64 chunk = 64
Init0 = 0x67452301 init0 = 0x67452301
Init1 = 0xEFCDAB89 init1 = 0xEFCDAB89
Init2 = 0x98BADCFE init2 = 0x98BADCFE
Init3 = 0x10325476 init3 = 0x10325476
Init4 = 0xC3D2E1F0 init4 = 0xC3D2E1F0
) )
// digest represents the partial evaluation of a checksum. // digest represents the partial evaluation of a checksum.
@ -40,13 +40,13 @@ mut:
} }
fn (d mut Digest) reset() { fn (d mut Digest) reset() {
d.x = [byte(0)].repeat(Chunk) d.x = [byte(0)].repeat(chunk)
d.h = [u32(0)].repeat(5) d.h = [u32(0)].repeat(5)
d.h[0] = u32(Init0) d.h[0] = u32(init0)
d.h[1] = u32(Init1) d.h[1] = u32(init1)
d.h[2] = u32(Init2) d.h[2] = u32(init2)
d.h[3] = u32(Init3) d.h[3] = u32(init3)
d.h[4] = u32(Init4) d.h[4] = u32(init4)
d.nx = 0 d.nx = 0
d.len = 0 d.len = 0
} }
@ -66,7 +66,7 @@ pub fn (d mut Digest) write(p_ []byte) ?int {
if d.nx > 0 { if d.nx > 0 {
n := copy(d.x.right(d.nx), p) n := copy(d.x.right(d.nx), p)
d.nx += n d.nx += n
if d.nx == Chunk { if d.nx == chunk {
block(d, d.x) block(d, d.x)
d.nx = 0 d.nx = 0
} }
@ -76,8 +76,8 @@ pub fn (d mut Digest) write(p_ []byte) ?int {
p = p.right(n) p = p.right(n)
} }
} }
if p.len >= Chunk { if p.len >= chunk {
n := p.len &~ (Chunk - 1) n := p.len &~ (chunk - 1)
block(d, p.left(n)) block(d, p.left(n))
if n >= p.len { if n >= p.len {
p = []byte p = []byte
@ -120,7 +120,7 @@ fn (d mut Digest) checksum() []byte {
binary.big_endian_put_u64(mut tmp, len) binary.big_endian_put_u64(mut tmp, len)
d.write(tmp.left(8)) d.write(tmp.left(8))
mut digest := [byte(0)].repeat(Size) mut digest := [byte(0)].repeat(size)
binary.big_endian_put_u32(mut digest, d.h[0]) binary.big_endian_put_u32(mut digest, d.h[0])
binary.big_endian_put_u32(mut digest.right(4), d.h[1]) binary.big_endian_put_u32(mut digest.right(4), d.h[1])
@ -144,8 +144,8 @@ fn block(dig &Digest, p []byte) {
block_generic(mut dig, p) block_generic(mut dig, p)
} }
pub fn (d &Digest) size() int { return Size } pub fn (d &Digest) size() int { return size }
pub fn (d &Digest) block_size() int { return BlockSize } pub fn (d &Digest) block_size() int { return block_size }
pub fn hexhash(s string) string { return sum(s.bytes()).hex() } pub fn hexhash(s string) string { return sum(s.bytes()).hex() }

26
vlib/crypto/sha1/sha1block_generic.v
View File

@ -11,10 +11,10 @@ module sha1
import math.bits import math.bits
const ( const (
_K0 = 0x5A827999 _k0 = 0x5A827999
_K1 = 0x6ED9EBA1 _k1 = 0x6ED9EBA1
_K2 = 0x8F1BBCDC _k2 = 0x8F1BBCDC
_K3 = 0xCA62C1D6 _k3 = 0xCA62C1D6
) )
fn block_generic(dig mut Digest, p_ []byte) { fn block_generic(dig mut Digest, p_ []byte) {
@ -25,7 +25,7 @@ fn block_generic(dig mut Digest, p_ []byte) {
mut h2 := dig.h[2] mut h2 := dig.h[2]
mut h3 := dig.h[3] mut h3 := dig.h[3]
mut h4 := dig.h[4] mut h4 := dig.h[4]
for p.len >= Chunk { for p.len >= chunk {
// Can interlace the computation of w with the // Can interlace the computation of w with the
// rounds below if needed for speed. // rounds below if needed for speed.
for i := 0; i < 16; i++ { for i := 0; i < 16; i++ {
@ -41,11 +41,11 @@ fn block_generic(dig mut Digest, p_ []byte) {
// Each of the four 20-iteration rounds // Each of the four 20-iteration rounds
// differs only in the computation of f and // differs only in the computation of f and
// the choice of K (_K0, _K1, etc). // the choice of K (_k0, _k1, etc).
mut i := 0 mut i := 0
for i < 16 { for i < 16 {
f := b&c | (~b)&d f := b&c | (~b)&d
t := bits.rotate_left_32(a, 5) + f + e + w[i&0xf] + u32(_K0) t := bits.rotate_left_32(a, 5) + f + e + w[i&0xf] + u32(_k0)
e = d e = d
d = c d = c
c = bits.rotate_left_32(b, 30) c = bits.rotate_left_32(b, 30)
@ -57,7 +57,7 @@ fn block_generic(dig mut Digest, p_ []byte) {
tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf] 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)) w[i&0xf] = tmp<<1 | u32(tmp>>(32-1))
f := b&c | (~b)&d f := b&c | (~b)&d
t := bits.rotate_left_32(a, 5) + f + e + w[i&0xf] + u32(_K0) t := bits.rotate_left_32(a, 5) + f + e + w[i&0xf] + u32(_k0)
e = d e = d
d = c d = c
c = bits.rotate_left_32(b, 30) c = bits.rotate_left_32(b, 30)
@ -69,7 +69,7 @@ fn block_generic(dig mut Digest, p_ []byte) {
tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf] 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)) w[i&0xf] = tmp<<1 | u32(tmp>>(32-1))
f := b ^ c ^ d f := b ^ c ^ d
t := bits.rotate_left_32(a, 5) + f + e + w[i&0xf] + u32(_K1) t := bits.rotate_left_32(a, 5) + f + e + w[i&0xf] + u32(_k1)
e = d e = d
d = c d = c
c = bits.rotate_left_32(b, 30) c = bits.rotate_left_32(b, 30)
@ -81,7 +81,7 @@ fn block_generic(dig mut Digest, p_ []byte) {
tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf] 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)) w[i&0xf] = tmp<<1 | u32(tmp>>(32-1))
f := ((b | c) & d) | (b & c) f := ((b | c) & d) | (b & c)
t := bits.rotate_left_32(a, 5) + f + e + w[i&0xf] + u32(_K2) t := bits.rotate_left_32(a, 5) + f + e + w[i&0xf] + u32(_k2)
e = d e = d
d = c d = c
c = bits.rotate_left_32(b, 30) c = bits.rotate_left_32(b, 30)
@ -93,7 +93,7 @@ fn block_generic(dig mut Digest, p_ []byte) {
tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf] 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)) w[i&0xf] = tmp<<1 | u32(tmp>>(32-1))
f := b ^ c ^ d f := b ^ c ^ d
t := bits.rotate_left_32(a, 5) + f + e + w[i&0xf] + u32(_K3) t := bits.rotate_left_32(a, 5) + f + e + w[i&0xf] + u32(_k3)
e = d e = d
d = c d = c
c = bits.rotate_left_32(b, 30) c = bits.rotate_left_32(b, 30)
@ -108,10 +108,10 @@ fn block_generic(dig mut Digest, p_ []byte) {
h3 += d h3 += d
h4 += e h4 += e
if Chunk >= p.len { if chunk >= p.len {
p = []byte p = []byte
} else { } else {
p = p.right(Chunk) p = p.right(chunk)
} }
} }

94
vlib/crypto/sha256/sha256.v
View File

@ -14,31 +14,31 @@ import encoding.binary
const ( const (
// The size of a SHA256 checksum in bytes. // The size of a SHA256 checksum in bytes.
Size = 32 size = 32
// The size of a SHA224 checksum in bytes. // The size of a SHA224 checksum in bytes.
Size224 = 28 size224 = 28
// The blocksize of SHA256 and SHA224 in bytes. // The blocksize of SHA256 and SHA224 in bytes.
BlockSize = 64 block_size = 64
) )
const ( const (
Chunk = 64 chunk = 64
Init0 = 0x6A09E667 init0 = 0x6A09E667
Init1 = 0xBB67AE85 init1 = 0xBB67AE85
Init2 = 0x3C6EF372 init2 = 0x3C6EF372
Init3 = 0xA54FF53A init3 = 0xA54FF53A
Init4 = 0x510E527F init4 = 0x510E527F
Init5 = 0x9B05688C init5 = 0x9B05688C
Init6 = 0x1F83D9AB init6 = 0x1F83D9AB
Init7 = 0x5BE0CD19 init7 = 0x5BE0CD19
Init0_224 = 0xC1059ED8 init0_224 = 0xC1059ED8
Init1_224 = 0x367CD507 init1_224 = 0x367CD507
Init2_224 = 0x3070DD17 init2_224 = 0x3070DD17
Init3_224 = 0xF70E5939 init3_224 = 0xF70E5939
Init4_224 = 0xFFC00B31 init4_224 = 0xFFC00B31
Init5_224 = 0x68581511 init5_224 = 0x68581511
Init6_224 = 0x64F98FA7 init6_224 = 0x64F98FA7
Init7_224 = 0xBEFA4FA4 init7_224 = 0xBEFA4FA4
) )
// digest represents the partial evaluation of a checksum. // digest represents the partial evaluation of a checksum.
@ -53,25 +53,25 @@ mut:
fn (d mut Digest) reset() { fn (d mut Digest) reset() {
d.h = [u32(0)].repeat(8) d.h = [u32(0)].repeat(8)
d.x = [byte(0)].repeat(Chunk) d.x = [byte(0)].repeat(chunk)
if !d.is224 { if !d.is224 {
d.h[0] = u32(Init0) d.h[0] = u32(init0)
d.h[1] = u32(Init1) d.h[1] = u32(init1)
d.h[2] = u32(Init2) d.h[2] = u32(init2)
d.h[3] = u32(Init3) d.h[3] = u32(init3)
d.h[4] = u32(Init4) d.h[4] = u32(init4)
d.h[5] = u32(Init5) d.h[5] = u32(init5)
d.h[6] = u32(Init6) d.h[6] = u32(init6)
d.h[7] = u32(Init7) d.h[7] = u32(init7)
} else { } else {
d.h[0] = u32(Init0_224) d.h[0] = u32(init0_224)
d.h[1] = u32(Init1_224) d.h[1] = u32(init1_224)
d.h[2] = u32(Init2_224) d.h[2] = u32(init2_224)
d.h[3] = u32(Init3_224) d.h[3] = u32(init3_224)
d.h[4] = u32(Init4_224) d.h[4] = u32(init4_224)
d.h[5] = u32(Init5_224) d.h[5] = u32(init5_224)
d.h[6] = u32(Init6_224) d.h[6] = u32(init6_224)
d.h[7] = u32(Init7_224) d.h[7] = u32(init7_224)
} }
d.nx = 0 d.nx = 0
d.len = 0 d.len = 0
@ -99,7 +99,7 @@ fn (d mut Digest) write(p_ []byte) ?int {
if d.nx > 0 { if d.nx > 0 {
n := copy(d.x.right(d.nx), p) n := copy(d.x.right(d.nx), p)
d.nx += n d.nx += n
if d.nx == Chunk { if d.nx == chunk {
block(mut d, d.x) block(mut d, d.x)
d.nx = 0 d.nx = 0
} }
@ -109,8 +109,8 @@ fn (d mut Digest) write(p_ []byte) ?int {
p = p.right(n) p = p.right(n)
} }
} }
if p.len >= Chunk { if p.len >= chunk {
n := p.len &~ (Chunk - 1) n := p.len &~ (chunk - 1)
block(mut d, p.left(n)) block(mut d, p.left(n))
if n >= p.len { if n >= p.len {
p = []byte p = []byte
@ -130,7 +130,7 @@ fn (d &Digest) sum(b_in []byte) []byte {
hash := d0.checksum() hash := d0.checksum()
mut b_out := b_in.clone() mut b_out := b_in.clone()
if d0.is224 { if d0.is224 {
for b in hash.left(Size224) { for b in hash.left(size224) {
b_out << b b_out << b
} }
} else { } else {
@ -161,7 +161,7 @@ fn (d mut Digest) checksum() []byte {
panic('d.nx != 0') panic('d.nx != 0')
} }
digest := [byte(0)].repeat(Size) digest := [byte(0)].repeat(size)
binary.big_endian_put_u32(mut digest, d.h[0]) binary.big_endian_put_u32(mut digest, d.h[0])
binary.big_endian_put_u32(mut digest.right(4), d.h[1]) binary.big_endian_put_u32(mut digest.right(4), d.h[1])
@ -194,8 +194,8 @@ pub fn sum224(data []byte) []byte {
mut d := new224() mut d := new224()
d.write(data) d.write(data)
sum := d.checksum() sum := d.checksum()
mut sum224 := [byte(0)].repeat(Size224) mut sum224 := [byte(0)].repeat(size224)
copy(sum224, sum.left(Size224)) copy(sum224, sum.left(size224))
return sum224 return sum224
} }
@ -207,12 +207,12 @@ fn block(dig mut Digest, p []byte) {
pub fn (d &Digest) size() int { pub fn (d &Digest) size() int {
if !d.is224 { if !d.is224 {
return Size return size
} }
return Size224 return size224
} }
pub fn (d &Digest) block_size() int { return BlockSize } pub fn (d &Digest) block_size() int { return block_size }
pub fn hexhash(s string) string { return sum256(s.bytes()).hex() } pub fn hexhash(s string) string { return sum256(s.bytes()).hex() }
pub fn hexhash_224(s string) string { return sum224(s.bytes()).hex() } pub fn hexhash_224(s string) string { return sum224(s.bytes()).hex() }

10
vlib/crypto/sha256/sha256block_generic.v
View File

@ -12,7 +12,7 @@ module sha256
import math.bits import math.bits
const ( const (
_K = [ _k = [
0x428a2f98, 0x428a2f98,
0x71374491, 0x71374491,
0xb5c0fbcf, 0xb5c0fbcf,
@ -94,7 +94,7 @@ fn block_generic(dig mut Digest, p_ []byte) {
mut h6 := dig.h[6] mut h6 := dig.h[6]
mut h7 := dig.h[7] mut h7 := dig.h[7]
for p.len >= Chunk { for p.len >= chunk {
// Can interlace the computation of w with the // Can interlace the computation of w with the
// rounds below if needed for speed. // rounds below if needed for speed.
for i := 0; i < 16; i++ { for i := 0; i < 16; i++ {
@ -119,7 +119,7 @@ fn block_generic(dig mut Digest, p_ []byte) {
mut h := h7 mut h := h7
for i := 0; i < 64; i++ { for i := 0; i < 64; i++ {
t1 := h + ((bits.rotate_left_32(e, -6)) ^ (bits.rotate_left_32(e, -11)) ^ (bits.rotate_left_32(e, -25))) + ((e & f) ^ (~e & g)) + u32(_K[i]) + w[i] t1 := h + ((bits.rotate_left_32(e, -6)) ^ (bits.rotate_left_32(e, -11)) ^ (bits.rotate_left_32(e, -25))) + ((e & f) ^ (~e & g)) + u32(_k[i]) + w[i]
t2 := ((bits.rotate_left_32(a, -2)) ^ (bits.rotate_left_32(a, -13)) ^ (bits.rotate_left_32(a, -22))) + ((a & b) ^ (a & c) ^ (b & c)) t2 := ((bits.rotate_left_32(a, -2)) ^ (bits.rotate_left_32(a, -13)) ^ (bits.rotate_left_32(a, -22))) + ((a & b) ^ (a & c) ^ (b & c))
h = g h = g
@ -141,10 +141,10 @@ fn block_generic(dig mut Digest, p_ []byte) {
h6 += g h6 += g
h7 += h h7 += h
if Chunk >= p.len { if chunk >= p.len {
p = []byte p = []byte
} else { } else {
p = p.right(Chunk) p = p.right(chunk)
} }
} }

214
vlib/crypto/sha512/sha512.v
View File

@ -16,53 +16,53 @@ import (
) )
const ( const (
// Size is the size, in bytes, of a SHA-512 checksum. // size is the size, in bytes, of a SHA-512 checksum.
Size = 64 size = 64
// Size224 is the size, in bytes, of a SHA-512/224 checksum. // size224 is the size, in bytes, of a SHA-512/224 checksum.
Size224 = 28 size224 = 28
// Size256 is the size, in bytes, of a SHA-512/256 checksum. // size256 is the size, in bytes, of a SHA-512/256 checksum.
Size256 = 32 size256 = 32
// Size384 is the size, in bytes, of a SHA-384 checksum. // size384 is the size, in bytes, of a SHA-384 checksum.
Size384 = 48 size384 = 48
// BlockSize is the block size, in bytes, of the SHA-512/224, // block_size is the block size, in bytes, of the SHA-512/224,
// SHA-512/256, SHA-384 and SHA-512 hash functions. // SHA-512/256, SHA-384 and SHA-512 hash functions.
BlockSize = 128 block_size = 128
) )
const ( const (
Chunk = 128 Chunk = 128
Init0 = 0x6a09e667f3bcc908 init0 = 0x6a09e667f3bcc908
Init1 = 0xbb67ae8584caa73b init1 = 0xbb67ae8584caa73b
Init2 = 0x3c6ef372fe94f82b init2 = 0x3c6ef372fe94f82b
Init3 = 0xa54ff53a5f1d36f1 init3 = 0xa54ff53a5f1d36f1
Init4 = 0x510e527fade682d1 init4 = 0x510e527fade682d1
Init5 = 0x9b05688c2b3e6c1f init5 = 0x9b05688c2b3e6c1f
Init6 = 0x1f83d9abfb41bd6b init6 = 0x1f83d9abfb41bd6b
Init7 = 0x5be0cd19137e2179 init7 = 0x5be0cd19137e2179
Init0_224 = 0x8c3d37c819544da2 init0_224 = 0x8c3d37c819544da2
Init1_224 = 0x73e1996689dcd4d6 init1_224 = 0x73e1996689dcd4d6
Init2_224 = 0x1dfab7ae32ff9c82 init2_224 = 0x1dfab7ae32ff9c82
Init3_224 = 0x679dd514582f9fcf init3_224 = 0x679dd514582f9fcf
Init4_224 = 0x0f6d2b697bd44da8 init4_224 = 0x0f6d2b697bd44da8
Init5_224 = 0x77e36f7304c48942 init5_224 = 0x77e36f7304c48942
Init6_224 = 0x3f9d85a86a1d36c8 init6_224 = 0x3f9d85a86a1d36c8
Init7_224 = 0x1112e6ad91d692a1 init7_224 = 0x1112e6ad91d692a1
Init0_256 = 0x22312194fc2bf72c init0_256 = 0x22312194fc2bf72c
Init1_256 = 0x9f555fa3c84c64c2 init1_256 = 0x9f555fa3c84c64c2
Init2_256 = 0x2393b86b6f53b151 init2_256 = 0x2393b86b6f53b151
Init3_256 = 0x963877195940eabd init3_256 = 0x963877195940eabd
Init4_256 = 0x96283ee2a88effe3 init4_256 = 0x96283ee2a88effe3
Init5_256 = 0xbe5e1e2553863992 init5_256 = 0xbe5e1e2553863992
Init6_256 = 0x2b0199fc2c85b8aa init6_256 = 0x2b0199fc2c85b8aa
Init7_256 = 0x0eb72ddc81c52ca2 init7_256 = 0x0eb72ddc81c52ca2
Init0_384 = 0xcbbb9d5dc1059ed8 init0_384 = 0xcbbb9d5dc1059ed8
Init1_384 = 0x629a292a367cd507 init1_384 = 0x629a292a367cd507
Init2_384 = 0x9159015a3070dd17 init2_384 = 0x9159015a3070dd17
Init3_384 = 0x152fecd8f70e5939 init3_384 = 0x152fecd8f70e5939
Init4_384 = 0x67332667ffc00b31 init4_384 = 0x67332667ffc00b31
Init5_384 = 0x8eb44a8768581511 init5_384 = 0x8eb44a8768581511
Init6_384 = 0xdb0c2e0d64f98fa7 init6_384 = 0xdb0c2e0d64f98fa7
Init7_384 = 0x47b5481dbefa4fa4 init7_384 = 0x47b5481dbefa4fa4
) )
// digest represents the partial evaluation of a checksum. // digest represents the partial evaluation of a checksum.
@ -79,42 +79,42 @@ fn (d mut Digest) reset() {
d.h = [u64(0)].repeat(8) d.h = [u64(0)].repeat(8)
d.x = [byte(0)].repeat(Chunk) d.x = [byte(0)].repeat(Chunk)
switch d.function { switch d.function {
case crypto.Hash.SHA384: case crypto.Hash.sha384:
d.h[0] = Init0_384 d.h[0] = init0_384
d.h[1] = Init1_384 d.h[1] = init1_384
d.h[2] = Init2_384 d.h[2] = init2_384
d.h[3] = Init3_384 d.h[3] = init3_384
d.h[4] = Init4_384 d.h[4] = init4_384
d.h[5] = Init5_384 d.h[5] = init5_384
d.h[6] = Init6_384 d.h[6] = init6_384
d.h[7] = Init7_384 d.h[7] = init7_384
case crypto.Hash.SHA512_224: case crypto.Hash.sha512_224:
d.h[0] = Init0_224 d.h[0] = init0_224
d.h[1] = Init1_224 d.h[1] = init1_224
d.h[2] = Init2_224 d.h[2] = init2_224
d.h[3] = Init3_224 d.h[3] = init3_224
d.h[4] = Init4_224 d.h[4] = init4_224
d.h[5] = Init5_224 d.h[5] = init5_224
d.h[6] = Init6_224 d.h[6] = init6_224
d.h[7] = Init7_224 d.h[7] = init7_224
case crypto.Hash.SHA512_256: case crypto.Hash.sha512_256:
d.h[0] = Init0_256 d.h[0] = init0_256
d.h[1] = Init1_256 d.h[1] = init1_256
d.h[2] = Init2_256 d.h[2] = init2_256
d.h[3] = Init3_256 d.h[3] = init3_256
d.h[4] = Init4_256 d.h[4] = init4_256
d.h[5] = Init5_256 d.h[5] = init5_256
d.h[6] = Init6_256 d.h[6] = init6_256
d.h[7] = Init7_256 d.h[7] = init7_256
default: default:
d.h[0] = Init0 d.h[0] = init0
d.h[1] = Init1 d.h[1] = init1
d.h[2] = Init2 d.h[2] = init2
d.h[3] = Init3 d.h[3] = init3
d.h[4] = Init4 d.h[4] = init4
d.h[5] = Init5 d.h[5] = init5
d.h[6] = Init6 d.h[6] = init6
d.h[7] = Init7 d.h[7] = init7
} }
d.nx = 0 d.nx = 0
d.len = 0 d.len = 0
@ -129,22 +129,22 @@ fn new_digest(hash crypto.Hash) &Digest {
// new returns a new Digest (implementing hash.Hash) computing the SHA-512 checksum. // new returns a new Digest (implementing hash.Hash) computing the SHA-512 checksum.
pub fn new() &Digest { pub fn new() &Digest {
return new_digest(crypto.Hash.SHA512) return new_digest(crypto.Hash.sha512)
} }
// new512_224 returns a new Digest (implementing hash.Hash) computing the SHA-512/224 checksum. // new512_224 returns a new Digest (implementing hash.Hash) computing the SHA-512/224 checksum.
fn new512_224() &Digest { fn new512_224() &Digest {
return new_digest(crypto.Hash.SHA512_224) return new_digest(crypto.Hash.sha512_224)
} }
// new512_256 returns a new Digest (implementing hash.Hash) computing the SHA-512/256 checksum. // new512_256 returns a new Digest (implementing hash.Hash) computing the SHA-512/256 checksum.
fn new512_256() &Digest { fn new512_256() &Digest {
return new_digest(crypto.Hash.SHA512_256) return new_digest(crypto.Hash.sha512_256)
} }
// new384 returns a new Digest (implementing hash.Hash) computing the SHA-384 checksum. // new384 returns a new Digest (implementing hash.Hash) computing the SHA-384 checksum.
fn new384() &Digest { fn new384() &Digest {
return new_digest(crypto.Hash.SHA384) return new_digest(crypto.Hash.sha384)
} }
fn (d mut Digest) write(p_ []byte) ?int { fn (d mut Digest) write(p_ []byte) ?int {
@ -185,16 +185,16 @@ fn (d mut Digest) sum(b_in []byte) []byte {
hash := d0.checksum() hash := d0.checksum()
mut b_out := b_in.clone() mut b_out := b_in.clone()
switch d0.function { switch d0.function {
case crypto.Hash.SHA384: case crypto.Hash.sha384:
for b in hash.left(Size384) { for b in hash.left(size384) {
b_out << b b_out << b
} }
case crypto.Hash.SHA512_224: case crypto.Hash.sha512_224:
for b in hash.left(Size224) { for b in hash.left(size224) {
b_out << b b_out << b
} }
case crypto.Hash.SHA512_256: case crypto.Hash.sha512_256:
for b in hash.left(Size256) { for b in hash.left(size256) {
b_out << b b_out << b
} }
default: default:
@ -228,7 +228,7 @@ fn (d mut Digest) checksum() []byte {
panic('d.nx != 0') panic('d.nx != 0')
} }
mut digest := [byte(0)].repeat(Size) mut digest := [byte(0)].repeat(size)
binary.big_endian_put_u64(mut digest, d.h[0]) binary.big_endian_put_u64(mut digest, d.h[0])
binary.big_endian_put_u64(mut digest.right(8), d.h[1]) binary.big_endian_put_u64(mut digest.right(8), d.h[1])
@ -236,7 +236,7 @@ fn (d mut Digest) checksum() []byte {
binary.big_endian_put_u64(mut digest.right(24), d.h[3]) binary.big_endian_put_u64(mut digest.right(24), d.h[3])
binary.big_endian_put_u64(mut digest.right(32), d.h[4]) binary.big_endian_put_u64(mut digest.right(32), d.h[4])
binary.big_endian_put_u64(mut digest.right(40), d.h[5]) binary.big_endian_put_u64(mut digest.right(40), d.h[5])
if d.function != crypto.Hash.SHA384 { if d.function != crypto.Hash.sha384 {
binary.big_endian_put_u64(mut digest.right(48), d.h[6]) binary.big_endian_put_u64(mut digest.right(48), d.h[6])
binary.big_endian_put_u64(mut digest.right(56), d.h[7]) binary.big_endian_put_u64(mut digest.right(56), d.h[7])
} }
@ -246,38 +246,38 @@ fn (d mut Digest) checksum() []byte {
// sum512 returns the SHA512 checksum of the data. // sum512 returns the SHA512 checksum of the data.
pub fn sum512(data []byte) []byte { pub fn sum512(data []byte) []byte {
mut d := new_digest(crypto.Hash.SHA512) mut d := new_digest(crypto.Hash.sha512)
d.write(data) d.write(data)
return d.checksum() return d.checksum()
} }
// sum384 returns the SHA384 checksum of the data. // sum384 returns the SHA384 checksum of the data.
pub fn sum384(data []byte) []byte { pub fn sum384(data []byte) []byte {
mut d := new_digest(crypto.Hash.SHA384) mut d := new_digest(crypto.Hash.sha384)
d.write(data) d.write(data)
sum := d.checksum() sum := d.checksum()
mut sum384 := [byte(0)].repeat(Size384) mut sum384 := [byte(0)].repeat(size384)
copy(sum384, sum.left(Size384)) copy(sum384, sum.left(size384))
return sum384 return sum384
} }
// sum512_224 returns the Sum512/224 checksum of the data. // sum512_224 returns the Sum512/224 checksum of the data.
pub fn sum512_224(data []byte) []byte { pub fn sum512_224(data []byte) []byte {
mut d := new_digest(crypto.Hash.SHA512_224) mut d := new_digest(crypto.Hash.sha512_224)
d.write(data) d.write(data)
sum := d.checksum() sum := d.checksum()
mut sum224 := [byte(0)].repeat(Size224) mut sum224 := [byte(0)].repeat(size224)
copy(sum224, sum.left(Size224)) copy(sum224, sum.left(size224))
return sum224 return sum224
} }
// Sum512_256 returns the Sum512/256 checksum of the data. // Sum512_256 returns the Sum512/256 checksum of the data.
pub fn sum512_256(data []byte) []byte { pub fn sum512_256(data []byte) []byte {
mut d := new_digest(crypto.Hash.SHA512_256) mut d := new_digest(crypto.Hash.sha512_256)
d.write(data) d.write(data)
sum := d.checksum() sum := d.checksum()
mut sum256 := [byte(0)].repeat(Size256) mut sum256 := [byte(0)].repeat(size256)
copy(sum256, sum.left(Size256)) copy(sum256, sum.left(size256))
return sum256 return sum256
} }
@ -289,18 +289,18 @@ fn block(dig mut Digest, p []byte) {
pub fn (d &Digest) size() int { pub fn (d &Digest) size() int {
switch d.function { switch d.function {
case crypto.Hash.SHA512_224: case crypto.Hash.sha512_224:
return Size224 return size224
case crypto.Hash.SHA512_256: case crypto.Hash.sha512_256:
return Size256 return size256
case crypto.Hash.SHA384: case crypto.Hash.sha384:
return Size384 return size384
default: default:
return Size return size
} }
} }
pub fn (d &Digest) block_size() int { return BlockSize } pub fn (d &Digest) block_size() int { return block_size }
pub fn hexhash(s string) string { return sum512(s.bytes()).hex() } pub fn hexhash(s string) string { return sum512(s.bytes()).hex() }
pub fn hexhash_384(s string) string { return sum384(s.bytes()).hex() } pub fn hexhash_384(s string) string { return sum384(s.bytes()).hex() }

4
vlib/crypto/sha512/sha512block_generic.v
View File

@ -12,7 +12,7 @@ module sha512
import math.bits import math.bits
const( const(
_K = [ _k = [
0x428a2f98d728ae22, 0x428a2f98d728ae22,
0x7137449123ef65cd, 0x7137449123ef65cd,
0xb5c0fbcfec4d3b2f, 0xb5c0fbcfec4d3b2f,
@ -135,7 +135,7 @@ fn block_generic(dig mut Digest, p_ []byte) {
mut h := h7 mut h := h7
for i := 0; i < 80; i++ { for i := 0; i < 80; i++ {
t1 := h + (bits.rotate_left_64(e, -14) ^ bits.rotate_left_64(e, -18) ^ bits.rotate_left_64(e, -41)) + ((e & f) ^ (~e & g)) + _K[i] + w[i] t1 := h + (bits.rotate_left_64(e, -14) ^ bits.rotate_left_64(e, -18) ^ bits.rotate_left_64(e, -41)) + ((e & f) ^ (~e & g)) + _k[i] + w[i]
t2 := (bits.rotate_left_64(a, -28) ^ bits.rotate_left_64(a, -34) ^ bits.rotate_left_64(a, -39)) + ((a & b) ^ (a & c) ^ (b & c)) t2 := (bits.rotate_left_64(a, -28) ^ bits.rotate_left_64(a, -34) ^ bits.rotate_left_64(a, -39)) + ((a & b) ^ (a & c) ^ (b & c))
h = g h = g

12
vlib/hash/crc32/crc32.v
View File

@ -8,14 +8,14 @@ module crc32
// polynomials // polynomials
const ( const (
IEEE = 0xedb88320 ieee = 0xedb88320
Castagnoli = 0x82f63b78 castagnoli = 0x82f63b78
Koopman = 0xeb31d82e koopman = 0xeb31d82e
) )
// The size of a CRC-32 checksum in bytes. // The size of a CRC-32 checksum in bytes.
const ( const (
Size = 4 size = 4
) )
struct Crc32 { struct Crc32 {
@ -56,8 +56,8 @@ pub fn new(poly int) &Crc32 {
return c return c
} }
// calculate crc32 using IEEE // calculate crc32 using ieee
pub fn sum(b []byte) u32 { pub fn sum(b []byte) u32 {
mut c := new(IEEE) mut c := new(ieee)
return c.sum32(b) return c.sum32(b)
} }

2
vlib/hash/crc32/crc32_test.v
View File

@ -7,7 +7,7 @@ fn test_hash_crc32() {
assert sum1.hex() == '0x483f8cf0' assert sum1.hex() == '0x483f8cf0'
c := crc32.new(crc32.IEEE) c := crc32.new(crc32.ieee)
b2 := 'testing crc32 again'.bytes() b2 := 'testing crc32 again'.bytes()
sum2 := c.checksum(b2) sum2 := c.checksum(b2)
assert sum2 == u32(1420327025) assert sum2 == u32(1420327025)