in progress

curve.go

@@ -1,4 +1,18 @@
 package curve
 
-type Curve interface {
+import (
+	"context"
+	"math/big"
+
+	"git.ali33.ru/fcg-xvii/curve/v2/tools"
+)
+
+func NewCurve(a, b, p *big.Int, ctx context.Context) (curve *tools.Curve, err error) {
+	if curve, err = tools.NewCurve(a, b); err != nil {
+		return
+	}
+	p = tools.SearchPrime(p)
+	curve.SetP(p)
+	err = curve.SetGRandom(ctx)
+	return
 }

dhellman/aes.go

@@ -0,0 +1,30 @@
+package dhellman
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+
+	"git.ali33.ru/fcg-xvii/curve/v2/tools"
+)
+
+func aesEncode(data []byte, p *tools.Point) ([]byte, error) {
+	block, err := aes.NewCipher(tools.Bytes32(p.X()))
+	if err != nil {
+		return nil, err
+	}
+	iv := tools.Bytes32(p.Y())[:aes.BlockSize]
+	stream := cipher.NewCFBEncrypter(block, iv)
+	stream.XORKeyStream(data, data)
+	return data, nil
+}
+
+func aesDecode(encrypted []byte, p *tools.Point) ([]byte, error) {
+	block, err := aes.NewCipher(tools.Bytes32(p.X()))
+	if err != nil {
+		return nil, err
+	}
+	iv := tools.Bytes32(p.Y())[:aes.BlockSize]
+	stream := cipher.NewCFBDecrypter(block, iv)
+	stream.XORKeyStream(encrypted, encrypted)
+	return encrypted, nil
+}

dhellman/curve_key_pair.go

@@ -0,0 +1,85 @@
+package dhellman
+
+import (
+	"errors"
+
+	"git.ali33.ru/fcg-xvii/curve/v2"
+	"git.ali33.ru/fcg-xvii/curve/v2/tools"
+)
+
+func randomCurveKeyPair(curve *tools.Curve) (*curveKeyPair, error) {
+	pair := curveKeyPair{
+		curve: curve,
+	}
+	var err error
+	if pair.priv, err = randomCurveKeyPrivate(curve); err != nil {
+		return nil, err
+	}
+	var pub *tools.Point
+	if pub, err = curve.G().Mul(pair.priv.x); err != nil {
+		return nil, err
+	}
+	pair.pub = &curveKeyPublic{
+		p: pub,
+	}
+	return &pair, nil
+}
+
+type curveKeyPair struct {
+	priv  *curveKeyPrivate
+	pub   *curveKeyPublic
+	curve *tools.Curve
+}
+
+func (s *curveKeyPair) KeyPrivate() curve.KeyPrivate {
+	return s.priv
+}
+
+func (s *curveKeyPair) KeyPublic() curve.KeyPublic {
+	return s.pub
+}
+
+func (s *curveKeyPair) MessageEncode(data []byte, args ...any) (curve.Message, error) {
+	if len(args) == 0 {
+		return nil, errors.New("Не найден публичный ключ принимающей стороны")
+	}
+	pub, check := args[0].(*curveKeyPublic)
+	if !check {
+		return nil, errors.New("Неверный тип аргумента - публичный ключ принимающей стороны")
+	}
+	encoded, err := s.messageEncode(data, pub)
+	if err != nil {
+		return nil, err
+	}
+	mes := &message{
+		encoded: encoded,
+	}
+	return mes, err
+}
+
+func (s *curveKeyPair) MessageDecode(mes curve.Message, args ...any) ([]byte, error) {
+	if len(args) == 0 {
+		return nil, errors.New("Не найден публичный ключ отправляющей стороны")
+	}
+	pub, check := args[0].(*curveKeyPublic)
+	if !check {
+		return nil, errors.New("Неверный тип аргумента - публичный ключ отправляющей стороны")
+	}
+	return s.messageDecode(mes.Encoded(), pub)
+}
+
+func (s *curveKeyPair) messageEncode(data []byte, pub *curveKeyPublic) ([]byte, error) {
+	sec, err := s.priv.secret(pub, s.curve)
+	if err != nil {
+		return nil, err
+	}
+	return aesEncode(data, sec)
+}
+
+func (s *curveKeyPair) messageDecode(encoded []byte, pub *curveKeyPublic) ([]byte, error) {
+	sec, err := s.priv.secret(pub, s.curve)
+	if err != nil {
+		return nil, err
+	}
+	return aesEncode(encoded, sec)
+}

dhellman/curve_key_private.go

@@ -0,0 +1,28 @@
+package dhellman
+
+import (
+	"math/big"
+
+	"git.ali33.ru/fcg-xvii/curve/v2/tools"
+)
+
+func randomCurveKeyPrivate(curve *tools.Curve) (priv *curveKeyPrivate, err error) {
+	if err = curve.IsValidP(); err != nil {
+		return
+	}
+	priv = &curveKeyPrivate{
+		x: tools.Random(big.NewInt(1), tools.Sub64(curve.P(), 1)),
+	}
+	return
+}
+
+type curveKeyPrivate struct {
+	x *big.Int
+}
+
+func (s *curveKeyPrivate) secret(pub *curveKeyPublic, curve *tools.Curve) (*tools.Point, error) {
+	if err := curve.IsValidG(); err != nil {
+		return nil, err
+	}
+	return pub.p.Mul(s.x)
+}

dhellman/key_public.go → dhellman/curve_key_public.go

@@ -2,6 +2,6 @@ package dhellman
 
 import "git.ali33.ru/fcg-xvii/curve/v2/tools"
 
-type keyPublic struct {
+type curveKeyPublic struct {
 	p *tools.Point
 }

dhellman/dhellman.go

@@ -1,7 +1,11 @@
 package dhellman
 
-import "git.ali33.ru/fcg-xvii/curve/v2"
+import (
+	"git.ali33.ru/fcg-xvii/curve/v2"
+	"git.ali33.ru/fcg-xvii/curve/v2/tools"
+)
 
-func constructor(curve curve.Curve) (curve.KeyPair, error) {
-	return nil, nil
+func CurveKeyPair(curve *tools.Curve) (curve.KeyPair, error) {
+	pair, err := randomCurveKeyPair(curve)
+	return pair, err
 }

dhellman/key_pair.go

@@ -1,9 +0,0 @@
-package dhellman
-
-import "git.ali33.ru/fcg-xvii/curve/v2/tools"
-
-type keyPair struct {
-	private *keyPrivate
-	public  *keyPublic
-	curve   *tools.Curve
-}

dhellman/key_private.go

@@ -1,12 +0,0 @@
-package dhellman
-
-import (
-	"math/big"
-
-	"git.ali33.ru/fcg-xvii/curve/v2/tools"
-)
-
-type keyPrivate struct {
-	curve *tools.Curve
-	x     *big.Int
-}

dhellman/message.go

@@ -0,0 +1,9 @@
+package dhellman
+
+type message struct {
+	encoded []byte
+}
+
+func (s *message) Encoded() []byte {
+	return s.encoded
+}

dhellman/z_test.go

@@ -1 +1,41 @@
 package dhellman
+
+import (
+	"context"
+	"log"
+	"math/big"
+	"testing"
+
+	"git.ali33.ru/fcg-xvii/curve/v2/tools"
+)
+
+func TestMessage(t *testing.T) {
+	c, err := tools.NewCurve(
+		big.NewInt(2),
+		big.NewInt(4),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	p := tools.SearchPrime(big.NewInt(1000))
+	if err = c.SetP(p); err != nil {
+		t.Fatal(err)
+	}
+	if err = c.SetGRandom(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	p1, _ := randomCurveKeyPair(c)
+	p2, _ := randomCurveKeyPair(c)
+
+	message := []byte("Hello, WORLD!!!")
+	encoded, err := p1.messageEncode(message, p2.pub)
+	if err != nil {
+		t.Fatal(err)
+	}
+	log.Println(encoded)
+	data, err := p2.messageDecode(encoded, p1.pub)
+	if err != nil {
+		t.Fatal(err)
+	}
+	log.Println(string(data))
+}

key_pair.go

@@ -3,6 +3,6 @@ package curve
 type KeyPair interface {
 	KeyPrivate() KeyPrivate
 	KeyPublic() KeyPublic
-	MessageEncode(data []byte) (Message, error)
-	MessageDecode(Message) ([]byte, error)
+	MessageEncode(data []byte, args ...any) (Message, error)
+	MessageDecode(mes Message, args ...any) ([]byte, error)
 }

key_private.go

@@ -1,5 +1,4 @@
 package curve
 
 type KeyPrivate interface {
-	MessageDecode(Message) ([]byte, error)
 }

key_public.go

@@ -1,5 +1,4 @@
 package curve
 
 type KeyPublic interface {
-	MessageEncode(data []byte) (Message, error)
 }

message.go

@@ -1,5 +1,5 @@
 package curve
 
 type Message interface {
-	Raw() []byte
+	Encoded() []byte
 }

method.go

@@ -0,0 +1 @@
+package curve

crypt.go → set.go

@@ -1,5 +1,7 @@
 package curve
 
-type Crypt interface {
+/*
+type Set interface {
 	KeyPair() (KeyPair, error)
 }
+*/

tools/bigint.go

@@ -88,3 +88,9 @@ func Split(x *big.Int, parts int, firstOffset, lastOffset *big.Int) [][]*big.Int
 	last[1] = Sub(last[1], lastOffset)
 	return res
 }
+
+func Bytes32(x *big.Int) []byte {
+	xb := x.Bytes()
+	ball := make([]byte, 32-len(xb))
+	return append(ball, xb...)
+}

tools/curve.go

@@ -1,9 +1,9 @@
 package tools
 
 import (
+	"context"
 	"errors"
 	"fmt"
-	"log"
 	"math/big"
 )
 
@@ -12,8 +12,7 @@ var (
 )
 
 // 4a³ + 27b² = 0 - проверка кривой на сингулярность
-
-func New(a, b *big.Int) (*Curve, error) {
+func NewCurve(a, b *big.Int) (*Curve, error) {
 	c := &Curve{
 		a: new(big.Int).Set(a),
 		b: new(big.Int).Set(b),
@@ -21,13 +20,26 @@ func New(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
 	p *big.Int // размер конечного поля
 	g *Point   // базовая точка подгруппы
-	n *big.Int // порядок подгруппы
-	h *big.Int // кофактор подгруппы
+	//n *big.Int // порядок подгруппы
+	//h *big.Int // кофактор подгруппы
 }
 
 func (s *Curve) A() (res *big.Int) {
@@ -38,6 +50,20 @@ func (s *Curve) B() (res *big.Int) {
 	return intCopy(s.b)
 }
 
+func (s *Curve) G() (res *Point) {
+	if s.g != nil {
+		res = s.g.Copy()
+	}
+	return
+}
+
+func (s *Curve) P() (res *big.Int) {
+	if s.p != nil {
+		res = intCopy(s.p)
+	}
+	return
+}
+
 // Проверка, установлен ли размер конечного поля
 func (s *Curve) IsValidP() (err error) {
 	if err = s.IsValidConstants(); err == nil {
@@ -57,15 +83,6 @@ func (s *Curve) IsValidG() (err error) {
 	return
 }
 
-func (s *Curve) IsValidN() (err error) {
-	if err = s.IsValidG(); err == nil {
-		if s.n == nil {
-			err = errors.New("порядок подгруппы не определен")
-		}
-	}
-	return
-}
-
 // Возвращает строку уравнения кривой
 func (s *Curve) FormulaString() string {
 	return fmt.Sprintf(
@@ -112,9 +129,6 @@ func (s *Curve) SetP(p *big.Int) (err error) {
 		return
 	}
 	s.p = p
-	// сброс подгруппы
-	s.n = nil
-	s.h = nil
 	return
 }
 
@@ -157,10 +171,10 @@ func (s *Curve) InverseMod(k, p *big.Int) (res *big.Int, err error) {
 }
 
 func (s *Curve) Points(dx *big.Int) (p1, p2 *Point, err error) {
-	if err = s.IsValidN(); err != nil {
+	if err = s.IsValidG(); err != nil {
 		return
 	}
-	return s.points(x)
+	return s.points(dx)
 }
 
 // Определение координат пары зеркальных точек по x
@@ -201,14 +215,14 @@ func (s *Curve) points(dx *big.Int) (p1, p2 *Point, err error) {
 	return
 }
 
-func (s *Curve) SearchClosePoints(x *big.Int) (p1, p2 *Point, err error) {
-	if err = s.IsValidN(); err != nil {
+func (s *Curve) SearchClosePoints(x *big.Int, ctx context.Context) (p1, p2 *Point, err error) {
+	if err = s.IsValidG(); err != nil {
 		return
 	}
-	return s.searhClosePoints(x)
+	return s.searhClosePoints(x, ctx)
 }
 
-func (s *Curve) searhClosePoints(x *big.Int) (p1, p2 *Point, err error) {
+func (s *Curve) searhClosePoints(x *big.Int, ctx context.Context) (p1, p2 *Point, err error) {
 	cx := intCopy(x)
 	if x.Cmp(s.p) >= 0 {
 		x = Sub(s.p, big.NewInt(1))
@@ -217,31 +231,45 @@ func (s *Curve) searhClosePoints(x *big.Int) (p1, p2 *Point, err error) {
 	}
 	//kx := Sub64(x, 1)
 	kx := intCopy(x)
-	for {
-		//log.Println("xkx", x, kx)
-		if x.Cmp(s.p) >= 0 && kx.Cmp(intZero) <= 0 {
-			err = fmt.Errorf("не удалось найти точки, близкие к [ %s ]", cx)
-			break
-		} else {
-			// Поиск вправо
-			if x.Cmp(s.p) <= 0 {
-				if p1, p2, err = s.points(x); err == nil {
-					if p1.IsInCurve() == nil {
-						return
+	ch := make(chan struct{})
+	go func() {
+		defer close(ch)
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			default:
+				//log.Println("xkx", x, kx)
+				if x.Cmp(s.p) >= 0 && kx.Cmp(intZero) <= 0 {
+					err = fmt.Errorf("не удалось найти точки, близкие к [ %s ]", cx)
+					return
+				} else {
+					// Поиск вправо
+					if x.Cmp(s.p) <= 0 {
+						if p1, p2, err = s.points(x); err == nil {
+							if p1.IsInCurve() == nil {
+								return
+							}
+						}
+						x = Add64(x, 1)
 					}
-				}
-				x = Add64(x, 1)
-			}
-			// Поиск влево
-			if kx.Cmp(intZero) < 0 {
-				if p1, p2, err = s.points(kx); err == nil {
-					if p1.IsInCurve() == nil {
-						return
+					// Поиск влево
+					if kx.Cmp(intZero) < 0 {
+						if p1, p2, err = s.points(kx); err == nil {
+							if p1.IsInCurve() == nil {
+								return
+							}
+						}
+						kx = Sub64(kx, 1)
 					}
 				}
-				kx = Sub64(kx, 1)
 			}
 		}
+	}()
+	select {
+	case <-ch:
+	case <-ctx.Done():
+		err = fmt.Errorf("Поиск точки, близкой к [ %v ] прерван - время вышло", x)
 	}
 	return
 }
@@ -260,7 +288,7 @@ func (s *Curve) SetG(g *Point) (err error) {
 	return
 }
 
-func (s *Curve) SetGRandom() (err error) {
+func (s *Curve) SetGRandom(ctx context.Context) (err error) {
 	if s.g != nil {
 		err = errors.New("базовая точка подгруппы g уже определена")
 		return
@@ -273,7 +301,7 @@ func (s *Curve) SetGRandom() (err error) {
 		Sub(s.p, big.NewInt(10)),
 	)
 	//log.Println(x)
-	p1, p2, err := s.searhClosePoints(x)
+	p1, p2, err := s.searhClosePoints(x, ctx)
 	if err != nil {
 		return
 	}
@@ -287,6 +315,7 @@ func (s *Curve) SetGRandom() (err error) {
 	return
 }
 
+/*
 // Поиск порядка подгруппы
 func (s *Curve) SetN() (err error) {
 	if s.n != nil {
@@ -445,6 +474,7 @@ func (s *Curve) ELKeyPair() (*ELKeyPair, error) {
 	}
 	return res, res.setupDataTable()
 }
+*/
 
 /*
 func (s *Curve) HEncode(b byte, pub *Point) (cm1, cm2 *Point, err error) {

tools/point.go

@@ -20,6 +20,14 @@ type Point struct {
 	curve *Curve
 }
 
+func (s *Point) X() *big.Int {
+	return intCopy(s.x)
+}
+
+func (s *Point) Y() *big.Int {
+	return intCopy(s.y)
+}
+
 func (s *Point) String() string {
 	return fmt.Sprintf("(%v, %v)", s.x, s.y)
 }
@@ -206,9 +214,8 @@ func (s *Point) Compare(pt *Point) (check bool, err error) {
 }
 
 func (s *Point) Mul(k *big.Int) (pt *Point, err error) {
-
 	if err = s.IsValid(); err == nil {
-		if err = s.curve.IsValidN(); err != nil {
+		if err = s.curve.IsValidG(); err != nil {
 			return
 		}
 	}

tools/z_test.go

@@ -3,7 +3,6 @@ package tools
 import (
 	"context"
 	"log"
-	"math"
 	"math/big"
 	"testing"
 	"time"
@@ -33,7 +32,7 @@ func TestSearchP(t *testing.T) {
 func TestFormula(t *testing.T) {
 	a, _ := big.NewInt(0).SetString("10", 10)
 	b, _ := big.NewInt(0).SetString("15", 10)
-	c, err := New(a, b)
+	c, err := NewCurve(a, b)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -43,7 +42,7 @@ func TestFormula(t *testing.T) {
 func TestSingular(t *testing.T) {
 	a := big.NewInt(0)
 	b := big.NewInt(0)
-	c, err := New(a, b)
+	c, err := NewCurve(a, b)
 	if err == nil {
 		t.Fatal(c.FormulaString(), ", не сингулярна")
 	}
@@ -71,7 +70,7 @@ func TestPointShow(t *testing.T) {
 }
 
 func TestCurveG(t *testing.T) {
-	curve, err := New(
+	curve, err := NewCurve(
 		big.NewInt(2),
 		big.NewInt(4),
 	)
@@ -91,64 +90,10 @@ func TestCurveG(t *testing.T) {
 	//log.Println("==============================")
 	//return
 	//log.Println(p1.Show(), p2.Show(), 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(curve.n)
-}
-
-func TestKeyPairs(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)
-	priv1, pub1, err := curve.RandomKeyPair()
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Log(priv1, pub1)
-	priv2, pub2, err := curve.RandomKeyPair()
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Log(priv2, pub2)
-	log.Println(curve.PointSecret(priv1, pub2))
-	log.Println(curve.PointSecret(priv2, pub1))
-
-	p1, err := curve.ELKeyPair()
-	if err != nil {
+	if err = curve.SetGRandom(context.Background()); err != nil {
 		t.Fatal(err)
 	}
-	t.Log(p1.priv.d)
-	t.Log(p1.pub.e1, p1.pub.e2)
-
-	mes, err := p1.EncodeMessage([]byte{5})
-	if err != nil {
-		t.Fatal(err)
-	}
-	log.Println(mes.c1)
-	log.Println(mes.cd)
-	p1.DecodeMessage(mes)
+	t.Log("G", curve.g)
 }
 
 /*
@@ -289,3 +234,10 @@ func TestSplit(t *testing.T) {
 	res := Split(x, parts, firstOffset, lastOffset)
 	log.Println(res)
 }
+
+func TestInt(t *testing.T) {
+	x := big.NewInt(100000000)
+	b := Bytes32(x)
+	dx := new(big.Int).SetBytes(b)
+	t.Log(x, dx, b)
+}

z_test.go

@@ -0,0 +1,22 @@
+package curve
+
+import (
+	"context"
+	"log"
+	"math/big"
+	"testing"
+	"time"
+
+	"git.ali33.ru/fcg-xvii/curve/v2/tools"
+)
+
+func TestCurveInit(t *testing.T) {
+	ctx, _ := context.WithDeadline(context.Background(), time.Now().Add(time.Second*3))
+	curve, err := NewCurve(
+		big.NewInt(2),
+		big.NewInt(4),
+		tools.Exp64(big.NewInt(2), 24),
+		ctx,
+	)
+	log.Println(curve, err)
+}