in progress

tools/bigint.go

@@ -28,6 +28,10 @@ func Mul(a, b *big.Int) *big.Int {
 	return new(big.Int).Mul(a, b)
 }
 
+func Mul64(a *big.Int, b int64) *big.Int {
+	return Mul(a, big.NewInt(b))
+}
+
 func Add(a, b *big.Int) *big.Int {
 	return new(big.Int).Add(a, b)
 }

tools/curve.go

@@ -22,19 +22,6 @@ func NewCurve(a, b *big.Int) (*Curve, error) {
 	return c, c.IsSingular()
 }
 
-/*
-func NewRandom(a, b *big.Int) (*Curve, error) {
-	c := Curve{
-		a: new(big.Int).Set(a),
-		b: new(big.Int).Set(b),
-	}
-	if err := c.IsSingular(); err != nil {
-		return nil, err
-	}
-
-}
-*/
-
 type Curve struct {
 	a *big.Int // константа a
 	b *big.Int // константа b

tools/tools.go

@@ -95,3 +95,21 @@ func Random(min, max *big.Int) *big.Int {
 	}
 	return res
 }
+
+// Проверка кривой на сингулярность (4a³ + 27b² = 0)
+func IsCurveSingular(a, b *big.Int) bool {
+	l := Mul64(Exp64(a, 3), 4)
+	r := Mul64(Exp64(b, 2), 27)
+	return l.Add(l, r).Cmp(intZero) == 0
+}
+
+func CurveRandomParams(max *big.Int) (a, b, p *big.Int) {
+	for {
+		a, b = Random(intZero, max), Random(intZero, max)
+		if !IsCurveSingular(a, b) {
+			break
+		}
+	}
+	p = SearchPrime(Random(intZero, max))
+	return
+}

tools/z_test.go

@@ -10,6 +10,20 @@ import (
 	"git.ali33.ru/fcg-xvii/go-tools/json"
 )
 
+func TestIsCurveSingular(t *testing.T) {
+	t.Log(IsCurveSingular(intZero, intZero))
+	t.Log(IsCurveSingular(big.NewInt(2), big.NewInt(4)))
+}
+
+func TestCurveRandom(t *testing.T) {
+	a, b, p := CurveRandomParams(big.NewInt(10000000))
+	t.Log(a, b, p)
+	cur, _ := NewCurve(a, b)
+	cur.SetP(p)
+	log.Println(cur.SetGRandom(context.Background()))
+	log.Println(cur.g)
+}
+
 func TestSearchP(t *testing.T) {
 	min := big.NewInt(1)
 	var g *big.Int
@@ -82,81 +96,12 @@ func TestCurveG(t *testing.T) {
 	if err = curve.SetP(p); err != nil {
 		t.Fatal(err)
 	}
-	//log.Println(curve.a, curve.b, curve.p)
-	//p1, _, err := curve.searhClosePoints(big.NewInt(1000000))
-	//log.Println("==============================")
-	//log.Println(p1.Show())
-	//log.Println(p2.Show())
-	//log.Println("==============================")
-	//return
-	//log.Println(p1.Show(), p2.Show(), err)
 	if err = curve.SetGRandom(context.Background()); err != nil {
 		t.Fatal(err)
 	}
 	t.Log("G", curve.g)
 }
 
-/*
-func TestGe(t *testing.T) {
-	curve, err := New(
-		big.NewInt(2),
-		big.NewInt(4),
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	p := SearchPrime(big.NewInt(int64(math.Pow(2, 10))))
-	log.Println("P", p)
-	if err = curve.SetP(p); err != nil {
-		t.Fatal(err)
-	}
-	if err = curve.SetGRandom(); err != nil {
-		t.Fatal(err)
-	}
-	t.Log("G", curve.g.Show())
-	if err = curve.SetN(); err != nil {
-		t.Fatal(err)
-	}
-	t.Log("N", curve.n)
-	v1, vp1 := curve.GKeyPair()
-	v2, vp2 := curve.GKeyPair()
-	t.Log(v1, vp1)
-	t.Log(v2, vp2)
-	e1, e2 := curve.GEncode(5, vp2)
-	t.Log(e1, e2)
-	curve.GDecode(e1, e2, v2)
-}
-*/
-
-/*
-func TestEncryptDecrypt(t *testing.T) {
-	p := SearchPrime(big.NewInt(int64(math.Pow(2, 10))))
-	g := Div64(Sub64(p, 1), 2)
-	priv := &PrivateKey{
-		PublicKey: PublicKey{
-			G: g,
-			P: p,
-		},
-		X: big.NewInt(20),
-	}
-	priv.Y = new(big.Int).Exp(priv.G, priv.X, priv.P)
-
-	message := []byte{5}
-	c1, c2, err := Encrypt(rand.Reader, &priv.PublicKey, message)
-	if err != nil {
-		t.Errorf("error encrypting: %s", err)
-	}
-	message2, err := Decrypt(priv, c1, c2)
-	if err != nil {
-		t.Errorf("error decrypting: %s", err)
-	}
-	if !bytes.Equal(message2, message) {
-		t.Errorf("decryption failed, got: %x, want: %x", message2, message)
-	}
-	log.Println(message, message2)
-}
-*/
-
 func TestJSON(t *testing.T) {
 	p := big.NewInt(0).SetBytes([]byte{10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10})
 	t.Log(p)
@@ -171,62 +116,10 @@ func TestJSON(t *testing.T) {
 	}`)
 	var jjm json.Map
 	json.Unmarshal(src, &jjm)
-	//pll := jjm.Value("p", big.NewInt(0))
 	pll, _ := big.NewInt(0).SetString(jjm.StringVal("p", ""), 10)
 	log.Printf("%T %s", pll, pll)
 }
 
-/*
-func TestCrypt(t *testing.T) {
-	jm := json.Map{}
-	ctx, _ := context.WithDeadline(context.Background(), time.Now().Add(time.Millisecond*1000))
-	cr, err := NewCrypt(jm, ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	c1 := cr.KeysGenerate(context.Background())
-	c2 := cr.KeysGenerate(context.Background())
-	log.Println(c1.priv.key, c1.pub.key)
-	log.Println(c2.priv.key, c2.pub.key)
-	text := "Hello, World!!! ;)"
-	log.Println(text)
-	log.Println([]byte(text))
-	mes := c2.pub.MessageEncode([]byte(text))
-	//mes := c2.pub.MessageEncode([]byte{15, 10})
-	log.Println(mes.a, mes.encrypted)
-	dData, err := c2.priv.MessageDecode(mes)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Log(string(dData))
-}
-*/
-
-/*
-func TestCryptBrutforceKey(t *testing.T) {
-	ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(time.Millisecond*1000))
-	defer cancel()
-	cr, err := NewCrypt(json.Map{}, ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	k1 := cr.KeysGenerate(context.Background())
-	mes := k1.pub.MessageEncode([]byte("Hello, WORLD!!! ;)"))
-	log.Println(k1.priv.key, k1.pub.key)
-	cctx, _ := context.WithDeadline(context.Background(), time.Now().Add(time.Second*10))
-	pair, err := cr.BrutforceKey(k1.pub, 4, cctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	log.Println(pair.priv.key, pair.pub.key)
-	dec, err := pair.priv.MessageDecode(mes)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Log(string(dec))
-}
-*/
-
 func TestSplit(t *testing.T) {
 	x := big.NewInt(1000)
 	parts := 2