in progress

dhellman/aes.go

@@ -8,23 +8,27 @@ import (
 )
 
 func aesEncode(data []byte, p *tools.Point) ([]byte, error) {
+	rData := make([]byte, len(data))
+	copy(rData, data)
 	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
+	stream.XORKeyStream(rData, rData)
+	return rData, nil
 }
 
 func aesDecode(encrypted []byte, p *tools.Point) ([]byte, error) {
+	rData := make([]byte, len(encrypted))
+	copy(rData, encrypted)
 	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
+	stream.XORKeyStream(rData, rData)
+	return rData, nil
 }

dhellman/curve_key_pair.go

@@ -2,6 +2,7 @@ package dhellman
 
 import (
 	"errors"
+	"log"
 
 	"git.ali33.ru/fcg-xvii/curve/v2"
 	"git.ali33.ru/fcg-xvii/curve/v2/tools"
@@ -81,7 +82,7 @@ func (s *curveKeyPair) MessageDecode(mes curve.Message, args ...any) ([]byte, er
 }
 
 func (s *curveKeyPair) messageEncode(data []byte, pub *curveKeyPublic) ([]byte, error) {
-	sec, err := s.priv.secret(pub, s.curve)
+	sec, err := s.priv.secret(pub)
 	if err != nil {
 		return nil, err
 	}
@@ -89,9 +90,10 @@ func (s *curveKeyPair) messageEncode(data []byte, pub *curveKeyPublic) ([]byte,
 }
 
 func (s *curveKeyPair) messageDecode(encoded []byte, pub *curveKeyPublic) ([]byte, error) {
-	sec, err := s.priv.secret(pub, s.curve)
+	sec, err := s.priv.secret(pub)
+	log.Println("SECRET", sec)
 	if err != nil {
 		return nil, err
 	}
-	return aesEncode(encoded, sec)
+	return aesDecode(encoded, sec)
 }

dhellman/curve_key_private.go

@@ -31,7 +31,8 @@ func (s *curveKeyPrivate) MarshalJSON() ([]byte, error) {
 	return s.Map().JSON(), nil
 }
 
-func (s *curveKeyPrivate) secret(pub *curveKeyPublic, curve *tools.Curve) (*tools.Point, error) {
+func (s *curveKeyPrivate) secret(pub *curveKeyPublic) (*tools.Point, error) {
+	curve := pub.p.Curve()
 	if err := curve.IsValidG(); err != nil {
 		return nil, err
 	}

dhellman/curve_key_public.go

@@ -24,21 +24,26 @@ func (s *curveKeyPublic) MarshalJSON() ([]byte, error) {
 	return s.Map().JSON(), nil
 }
 
-func (s *curveKeyPublic) Attack(ctx context.Context) (curve.KeyPrivate, error) {
-	return s.attack(ctx)
+func (s *curveKeyPublic) Attack(ctx context.Context) (curve.KeyPair, error) {
+	return nil, nil
 }
 
-func (s *curveKeyPublic) attack(ctx context.Context) (*curveKeyPrivate, error) {
+func (s *curveKeyPublic) attack(ctx context.Context) (*curveKeyPair, error) {
 	c := s.p.Curve()
 	tmp := big.NewInt(1)
 	for {
 		if tmp.Cmp(tools.Add64(c.P(), -1)) == 0 {
 			break
 		}
-		if pp, err := c.G().Mul(tmp); err == nil && pp.X().Cmp(s.p.X()) == 0 {
-			return &curveKeyPrivate{
-				x: tmp,
-			}, nil
+		if pp, err := c.G().Mul(tmp); err == nil && pp.X() != nil && pp.X().Cmp(s.p.X()) == 0 && pp.Y().Cmp(s.p.Y()) == 0 {
+			pair := &curveKeyPair{
+				curve: c,
+				pub:   s,
+				priv: &curveKeyPrivate{
+					x: tmp,
+				},
+			}
+			return pair, nil
 		}
 		select {
 		case <-ctx.Done():

dhellman/z_test.go

@@ -17,7 +17,7 @@ func TestMessage(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	p := tools.SearchPrime(big.NewInt(1000000))
+	p := tools.SearchPrime(big.NewInt(10000))
 	if err = c.SetP(p); err != nil {
 		t.Fatal(err)
 	}
@@ -26,6 +26,10 @@ func TestMessage(t *testing.T) {
 	}
 	p1, _ := randomCurveKeyPair(c)
 	p2, _ := randomCurveKeyPair(c)
+	log.Println(p1.priv.x, p1.pub.p)
+	log.Println(p2.priv.x, p2.pub.p)
+	log.Println(p1.priv.secret(p2.pub))
+	log.Println(p2.priv.secret(p1.pub))
 
 	message := []byte("Hello, WORLD!!!")
 	encoded, err := p1.messageEncode(message, p2.pub)
@@ -38,9 +42,18 @@ func TestMessage(t *testing.T) {
 		t.Fatal(err)
 	}
 	log.Println(string(data))
-	aPriv, err := p1.pub.attack(context.Background())
+	aPair, err := p2.pub.attack(context.Background())
 	if err != nil {
 		t.Fatal(err)
 	}
-	log.Println(aPriv.x, p1.priv.x)
+	p2.Map().LogPretty()
+	aPair.Map().LogPretty()
+	log.Println(p1.priv.secret(p2.pub))
+	log.Println(p2.priv.secret(p1.pub))
+	log.Println(aPair.priv.secret(p1.pub))
+
+	data, err = p2.messageDecode(encoded, p1.pub)
+	log.Println(string(data), err)
+	data, err = aPair.messageDecode(encoded, p1.pub)
+	log.Println(string(data), err)
 }

key_public.go

@@ -3,5 +3,5 @@ package curve
 import "context"
 
 type KeyPublic interface {
-	Attack(context.Context) (KeyPrivate, error)
+	Attack(context.Context) (KeyPair, error)
 }