mirror/v
1
0
Fork 0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
Code Issues Projects Releases Wiki Activity

checker: make using err.msg and err.code produce an *actual* notice, even with the present compatibility hack (will be *removed* in 2022-06-01)

Browse Source
This commit is contained in:
Delyan Angelov
2022-04-12 13:38:40 +03:00
parent 4c7cdd2a2d
commit 8788512c4d
28 changed files with 107 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -170,7 +170,7 @@ fn new_key_from_seed_generic(mut privatekey []byte, seed []byte) {
mut h := sha512.sum512(seed)
mut s := edwards25519.new_scalar()
s.set_bytes_with_clamping(h[..32]) or { panic(err.msg) }
s.set_bytes_with_clamping(h[..32]) or { panic(err) }
mut aa := edwards25519.Point{}
aa.scalar_base_mult(mut s)

6
vlib/crypto/ed25519/examples/example.v
View File

@@ -8,11 +8,11 @@ import crypto.ed25519
fn main() {
msg := 'Hello Girl'
publ, priv := ed25519.generate_key() or { panic(err.msg) }
publ, priv := ed25519.generate_key() ?
m := msg.bytes()
sig := ed25519.sign(priv, m) or { panic(err.msg) }
sig := ed25519.sign(priv, m) ?
println('=== Message ===')
println('Msg: $msg \nHash: $m')
@@ -31,7 +31,7 @@ fn main() {
println('signature: R=${sig[0..32].hex()} s=${sig[32..64].hex()}')
println(' signature (Base64)=${base64.encode(sig)}')
rtn := ed25519.verify(publ, m, sig) or { panic(err.msg) }
rtn := ed25519.verify(publ, m, sig) ?
if rtn {
println('Signature verified :$rtn')

16
vlib/crypto/ed25519/internal/ed25519_test.v
View File

@@ -85,10 +85,10 @@ fn works_check_on_sign_input_string(item string) bool {
return false
}
// assert parts.len == 5
privbytes := hex.decode(parts[0]) or { panic(err.msg) }
pubkey := hex.decode(parts[1]) or { panic(err.msg) }
msg := hex.decode(parts[2]) or { panic(err.msg) }
mut sig := hex.decode(parts[3]) or { panic(err.msg) }
privbytes := hex.decode(parts[0]) or { panic(err) }
pubkey := hex.decode(parts[1]) or { panic(err) }
msg := hex.decode(parts[2]) or { panic(err) }
mut sig := hex.decode(parts[3]) or { panic(err) }
if pubkey.len != ed25519.public_key_size {
return false
@@ -100,12 +100,12 @@ fn works_check_on_sign_input_string(item string) bool {
copy(mut priv[..], privbytes)
copy(mut priv[32..], pubkey)
sig2 := ed25519.sign(priv[..], msg) or { panic(err.msg) }
sig2 := ed25519.sign(priv[..], msg) or { panic(err) }
if sig != sig2[..] {
return false
}
res := ed25519.verify(pubkey, msg, sig2) or { panic(err.msg) }
res := ed25519.verify(pubkey, msg, sig2) or { panic(err) }
// assert res == true
if !res {
return false
@@ -150,7 +150,7 @@ mut:
// so, maybe need a long time to finish.
// be quiet and patient
fn test_input_from_djb_ed25519_crypto_sign_input_with_syncpool() ? {
// contents := os.read_lines('testdata/sign.input') or { panic(err.msg) } //[]string
// contents := os.read_lines('testdata/sign.input') or { panic(err) } //[]string
mut pool_s := pool.new_pool_processor(
callback: worker_for_string_content
maxjobs: 4
@@ -165,7 +165,7 @@ fn test_input_from_djb_ed25519_crypto_sign_input_with_syncpool() ? {
// same as above, but without sync.pool
/*
fn test_input_from_djb_ed25519_crypto_sign_input_without_syncpool() ? {
// contents := os.read_lines('testdata/sign.input') or { panic(err.msg) } //[]string
// contents := os.read_lines('testdata/sign.input') or { panic(err) } //[]string
for i, item in ed25519.contents {
parts := item.split(':') // []string
// println(parts)

4
vlib/crypto/ed25519/internal/edwards25519/element_test.v
View File

@@ -387,11 +387,11 @@ fn test_bytes_big_equivalence() ? {
mut fe := el.generate_element()
mut fe1 := el.generate_element()
fe.set_bytes(inp) or { panic(err.msg) }
fe.set_bytes(inp) or { panic(err) }
inp[inp.len - 1] &= (1 << 7) - 1 // mask the most significant bit
mut b := big.integer_from_bytes(swap_endianness(mut inp)) // need swap_endianness
fe1.from_big_integer(b) or { panic(err.msg) } // do swap_endianness internally
fe1.from_big_integer(b) or { panic(err) } // do swap_endianness internally
assert fe == fe1

24
vlib/crypto/ed25519/internal/edwards25519/extra_test.v
View File

@@ -67,20 +67,20 @@ fn test_bytes_montgomery_infinity() {
const (
loworder_string = '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc85'
loworder_bytes = hex.decode(loworder_string) or { panic(err.msg) }
loworder_bytes = hex.decode(loworder_string) or { panic(err) }
)
fn fn_cofactor(mut data []byte) bool {
if data.len != 64 {
panic('err.msg')
panic('data.len should be 64')
}
mut loworder := Point{}
loworder.set_bytes(edwards25519.loworder_bytes) or { panic(err.msg) }
loworder.set_bytes(edwards25519.loworder_bytes) or { panic(err) }
mut s := new_scalar()
mut p := Point{}
mut p8 := Point{}
s.set_uniform_bytes(data) or { panic(err.msg) }
s.set_uniform_bytes(data) or { panic(err) }
p.scalar_base_mult(mut s)
p8.mult_by_cofactor(p)
@@ -128,8 +128,8 @@ fn invert_works(mut xinv Scalar, x NotZeroScalar) bool {
}
fn test_scalar_invert() {
nsc := generate_notzero_scalar(5) or { panic(err.msg) }
mut xsc := generate_scalar(5) or { panic(err.msg) }
nsc := generate_notzero_scalar(5) or { panic(err) }
mut xsc := generate_scalar(5) or { panic(err) }
assert invert_works(mut xsc, nsc) == true
mut zero := new_scalar()
@@ -140,9 +140,9 @@ fn test_scalar_invert() {
fn test_multiscalarmultmatchesbasemult() {
for i in 0 .. 6 {
x := generate_scalar(100) or { panic(err.msg) }
y := generate_scalar(5) or { panic(err.msg) }
z := generate_scalar(2) or { panic(err.msg) }
x := generate_scalar(100) or { panic(err) }
y := generate_scalar(5) or { panic(err) }
z := generate_scalar(2) or { panic(err) }
assert multiscalarmultmatchesbasemult(x, y, z) == true
}
}
@@ -196,9 +196,9 @@ fn vartime_multiscala_rmultmatches_basemult(xx Scalar, yy Scalar, zz Scalar) boo
fn test_vartimemultiscalarmultmatchesbasemult() {
for i in 0 .. 5 {
x := generate_scalar(100) or { panic(err.msg) }
y := generate_scalar(5) or { panic(err.msg) }
z := generate_scalar(2) or { panic(err.msg) }
x := generate_scalar(100) or { panic(err) }
y := generate_scalar(5) or { panic(err) }
z := generate_scalar(2) or { panic(err) }
assert vartime_multiscala_rmultmatches_basemult(x, y, z) == true
}
}

8
vlib/crypto/ed25519/internal/edwards25519/point.v
View File

@@ -10,12 +10,12 @@ const (
gen_bytes = [byte(0x58), 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
0x66, 0x66, 0x66, 0x66, 0x66]
d_const = d_const_generate() or { panic(err.msg) }
d2_const = d2_const_generate() or { panic(err.msg) }
d_const = d_const_generate() or { panic(err) }
d2_const = d2_const_generate() or { panic(err) }
// id_point is the point at infinity.
id_point = id_point_generate() or { panic(err.msg) }
id_point = id_point_generate() or { panic(err) }
// generator point
gen_point = generator() or { panic(err.msg) }
gen_point = generator() or { panic(err) }
)
fn d_const_generate() ?Element {

26
vlib/crypto/ed25519/internal/edwards25519/scalar_test.v
View File

@@ -58,8 +58,8 @@ fn addlike_subneg(x Scalar, y Scalar) bool {
fn test_scalar_add_like_subneg() {
for i in 0 .. 15 {
x := generate_scalar(1000) or { panic(err.msg) }
y := generate_scalar(1000) or { panic(err.msg) }
x := generate_scalar(1000) or { panic(err) }
y := generate_scalar(1000) or { panic(err) }
assert addlike_subneg(x, y) == true
}
}
@@ -70,7 +70,7 @@ fn fg(sc Scalar) bool {
fn test_scalar_generate() ? {
for i in 0 .. 15 {
sc := generate_scalar(1000) or { panic(err.msg) }
sc := generate_scalar(1000) or { panic(err) }
assert fg(sc) == true
}
@@ -79,10 +79,10 @@ fn test_scalar_generate() ? {
//
fn test_scalar_set_canonical_bytes() ? {
for i in 0 .. 10 {
mut buf := rand.bytes(32) or { panic(err.msg) }
mut sc := generate_scalar(1000) or { panic(err.msg) }
mut buf := rand.bytes(32) or { panic(err) }
mut sc := generate_scalar(1000) or { panic(err) }
buf[buf.len - 1] &= (1 << 4) - 1
sc = sc.set_canonical_bytes(buf) or { panic(err.msg) }
sc = sc.set_canonical_bytes(buf) or { panic(err) }
assert buf[..] == sc.bytes()
assert is_reduced(sc)
@@ -93,7 +93,7 @@ fn test_scalar_set_canonical_bytes_round_trip() ? {
for i in 0 .. 10 {
mut sc1 := generate_scalar(2) ?
mut sc2 := generate_scalar(6) ?
sc2.set_canonical_bytes(sc1.bytes()) or { panic(err.msg) }
sc2.set_canonical_bytes(sc1.bytes()) or { panic(err) }
assert sc1 == sc2
}
@@ -152,10 +152,10 @@ fn test_scalar_set_bytes_with_clamping() {
t.Errorf("random: got %q, want %q", got, want)
}*/
random := '633d368491364dc9cd4c1bf891b1d59460face1644813240a313e61f2c88216e'
random_bytes := hex.decode(random) or { panic(err.msg) }
random_bytes := hex.decode(random) or { panic(err) }
mut s0 := Scalar{}
s0.set_bytes_with_clamping(random_bytes) or { panic(err.msg) }
s0.set_bytes_with_clamping(random_bytes) or { panic(err) }
mut p0 := Point{}
p0.scalar_base_mult(mut s0)
@@ -167,8 +167,8 @@ fn test_scalar_set_bytes_with_clamping() {
zero := '0000000000000000000000000000000000000000000000000000000000000000'
mut s1 := Scalar{}
zero_bytes := hex.decode(zero) or { panic(err.msg) }
s1.set_bytes_with_clamping(zero_bytes) or { panic(err.msg) }
zero_bytes := hex.decode(zero) or { panic(err) }
s1.set_bytes_with_clamping(zero_bytes) or { panic(err) }
mut p1 := Point{}
p1.scalar_base_mult(mut s1)
@@ -178,8 +178,8 @@ fn test_scalar_set_bytes_with_clamping() {
one := 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
mut s2 := Scalar{}
mut one_bytes := hex.decode(one) or { panic(err.msg) }
s2.set_bytes_with_clamping(one_bytes) or { panic(err.msg) }
mut one_bytes := hex.decode(one) or { panic(err) }
s2.set_bytes_with_clamping(one_bytes) or { panic(err) }
mut p2 := Point{}
p2.scalar_base_mult(mut s2)

12
vlib/crypto/ed25519/internal/edwards25519/scalarmult_test.v
View File

@@ -10,7 +10,7 @@ const (
fn dalek_scalar_basepoint() Point {
mut p := Point{}
p.set_bytes(edwards25519.dsc_basepoint) or { panic(err.msg) }
p.set_bytes(edwards25519.dsc_basepoint) or { panic(err) }
return p
}
@@ -70,8 +70,8 @@ fn test_vartime_double_basemult_vs_dalek() {
}
fn test_scalar_mult_distributes_over_add() {
mut x := generate_scalar(100) or { panic(err.msg) }
mut y := generate_scalar(100) or { panic(err.msg) }
mut x := generate_scalar(100) or { panic(err) }
mut y := generate_scalar(100) or { panic(err) }
mut z := Scalar{}
z.add(x, y)
@@ -142,7 +142,7 @@ fn test_basepoint_table_generation() {
}
fn test_scalar_mult_matches_base_mult() {
mut x := generate_scalar(100) or { panic(err.msg) }
mut x := generate_scalar(100) or { panic(err) }
b := new_generator_point()
mut p := Point{}
mut q := Point{}
@@ -165,8 +165,8 @@ fn test_basepoint_naf_table_generation() {
}
fn test_vartime_double_scalar_base_mult() {
mut x := generate_scalar(100) or { panic(err.msg) }
mut y := generate_scalar(100) or { panic(err.msg) }
mut x := generate_scalar(100) or { panic(err) }
mut y := generate_scalar(100) or { panic(err) }
b := new_generator_point()
mut p := Point{}