github.com/ulerdogan/caigo@v0.1.3/curve_test.go (about)

     1  package caigo
     2  
     3  import (
     4  	"fmt"
     5  	"math/big"
     6  	"testing"
     7  
     8  	"github.com/ulerdogan/caigo/types"
     9  )
    10  
    11  func BenchmarkPedersenHash(b *testing.B) {
    12  	suite := [][]*big.Int{
    13  		{types.HexToBN("0x12773"), types.HexToBN("0x872362")},
    14  		{types.HexToBN("0x1277312773"), types.HexToBN("0x872362872362")},
    15  		{types.HexToBN("0x1277312773"), types.HexToBN("0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826")},
    16  		{types.HexToBN("0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"), types.HexToBN("0x872362872362")},
    17  		{types.HexToBN("0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"), types.HexToBN("0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB")},
    18  		{types.HexToBN("0x7f15c38ea577a26f4f553282fcfe4f1feeb8ecfaad8f221ae41abf8224cbddd"), types.HexToBN("0x13d41f388b8ea4db56c5aa6562f13359fab192b3db57651af916790f9debee9")},
    19  		{types.HexToBN("0x7f15c38ea577a26f4f553282fcfe4f1feeb8ecfaad8f221ae41abf8224cbddd"), types.HexToBN("0x7f15c38ea577a26f4f553282fcfe4f1feeb8ecfaad8f221ae41abf8224cbdde")},
    20  	}
    21  
    22  	for _, test := range suite {
    23  		b.Run(fmt.Sprintf("input_size_%d_%d", test[0].BitLen(), test[1].BitLen()), func(b *testing.B) {
    24  			Curve.PedersenHash(test)
    25  		})
    26  	}
    27  }
    28  
    29  func BenchmarkCurveSign(b *testing.B) {
    30  	type data struct {
    31  		MessageHash *big.Int
    32  		PrivateKey  *big.Int
    33  		Seed        *big.Int
    34  	}
    35  
    36  	dataSet := []data{}
    37  	MessageHash := big.NewInt(0).Exp(big.NewInt(2), big.NewInt(250), nil)
    38  	PrivateKey := big.NewInt(0).Add(MessageHash, big.NewInt(1))
    39  	Seed := big.NewInt(0)
    40  	for i := int64(0); i < 20; i++ {
    41  		dataSet = append(dataSet, data{
    42  			MessageHash: big.NewInt(0).Add(MessageHash, big.NewInt(i)),
    43  			PrivateKey:  big.NewInt(0).Add(PrivateKey, big.NewInt(i)),
    44  			Seed:        big.NewInt(0).Add(Seed, big.NewInt(i)),
    45  		})
    46  
    47  		for _, test := range dataSet {
    48  			Curve.Sign(test.MessageHash, test.PrivateKey, test.Seed)
    49  		}
    50  	}
    51  }
    52  
    53  func TestGeneral_PrivateToPoint(t *testing.T) {
    54  	x, _, err := Curve.PrivateToPoint(big.NewInt(2))
    55  	if err != nil {
    56  		t.Errorf("PrivateToPoint err %v", err)
    57  	}
    58  	expectedX, _ := new(big.Int).SetString("3324833730090626974525872402899302150520188025637965566623476530814354734325", 10)
    59  	if x.Cmp(expectedX) != 0 {
    60  		t.Errorf("Actual public key %v different from expected %v", x, expectedX)
    61  	}
    62  }
    63  
    64  func TestGeneral_PedersenHash(t *testing.T) {
    65  	testPedersen := []struct {
    66  		elements []*big.Int
    67  		expected *big.Int
    68  	}{
    69  		{
    70  			elements: []*big.Int{types.HexToBN("0x12773"), types.HexToBN("0x872362")},
    71  			expected: types.HexToBN("0x5ed2703dfdb505c587700ce2ebfcab5b3515cd7e6114817e6026ec9d4b364ca"),
    72  		},
    73  		{
    74  			elements: []*big.Int{types.HexToBN("0x13d41f388b8ea4db56c5aa6562f13359fab192b3db57651af916790f9debee9"), types.HexToBN("0x537461726b4e6574204d61696c")},
    75  			expected: types.HexToBN("0x180c0a3d13c1adfaa5cbc251f4fc93cc0e26cec30ca4c247305a7ce50ac807c"),
    76  		},
    77  		{
    78  			elements: []*big.Int{big.NewInt(100), big.NewInt(1000)},
    79  			expected: types.HexToBN("0x45a62091df6da02dce4250cb67597444d1f465319908486b836f48d0f8bf6e7"),
    80  		},
    81  	}
    82  
    83  	for _, tt := range testPedersen {
    84  		hash, err := Curve.PedersenHash(tt.elements)
    85  		if err != nil {
    86  			t.Errorf("Hashing err: %v\n", err)
    87  		}
    88  		if hash.Cmp(tt.expected) != 0 {
    89  			t.Errorf("incorrect hash: got %v expected %v\n", hash, tt.expected)
    90  		}
    91  	}
    92  }
    93  
    94  func TestGeneral_DivMod(t *testing.T) {
    95  	testDivmod := []struct {
    96  		x        *big.Int
    97  		y        *big.Int
    98  		expected *big.Int
    99  	}{
   100  		{
   101  			x:        types.StrToBig("311379432064974854430469844112069886938521247361583891764940938105250923060"),
   102  			y:        types.StrToBig("621253665351494585790174448601059271924288186997865022894315848222045687999"),
   103  			expected: types.StrToBig("2577265149861519081806762825827825639379641276854712526969977081060187505740"),
   104  		},
   105  		{
   106  			x:        big.NewInt(1),
   107  			y:        big.NewInt(2),
   108  			expected: types.HexToBN("0x0400000000000008800000000000000000000000000000000000000000000001"),
   109  		},
   110  	}
   111  
   112  	for _, tt := range testDivmod {
   113  		divR := DivMod(tt.x, tt.y, Curve.P)
   114  
   115  		if divR.Cmp(tt.expected) != 0 {
   116  			t.Errorf("DivMod Res %v does not == expected %v\n", divR, tt.expected)
   117  		}
   118  	}
   119  }
   120  
   121  func TestGeneral_Add(t *testing.T) {
   122  	testAdd := []struct {
   123  		x         *big.Int
   124  		y         *big.Int
   125  		expectedX *big.Int
   126  		expectedY *big.Int
   127  	}{
   128  		{
   129  			x:         types.StrToBig("1468732614996758835380505372879805860898778283940581072611506469031548393285"),
   130  			y:         types.StrToBig("1402551897475685522592936265087340527872184619899218186422141407423956771926"),
   131  			expectedX: types.StrToBig("2573054162739002771275146649287762003525422629677678278801887452213127777391"),
   132  			expectedY: types.StrToBig("3086444303034188041185211625370405120551769541291810669307042006593736192813"),
   133  		},
   134  		{
   135  			x:         big.NewInt(1),
   136  			y:         big.NewInt(2),
   137  			expectedX: types.StrToBig("225199957243206662471193729647752088571005624230831233470296838210993906468"),
   138  			expectedY: types.StrToBig("190092378222341939862849656213289777723812734888226565973306202593691957981"),
   139  		},
   140  	}
   141  
   142  	for _, tt := range testAdd {
   143  		resX, resY := Curve.Add(Curve.Gx, Curve.Gy, tt.x, tt.y)
   144  		if resX.Cmp(tt.expectedX) != 0 {
   145  			t.Errorf("ResX %v does not == expected %v\n", resX, tt.expectedX)
   146  
   147  		}
   148  		if resY.Cmp(tt.expectedY) != 0 {
   149  			t.Errorf("ResY %v does not == expected %v\n", resY, tt.expectedY)
   150  		}
   151  	}
   152  }
   153  
   154  func TestGeneral_MultAir(t *testing.T) {
   155  	testMult := []struct {
   156  		r         *big.Int
   157  		x         *big.Int
   158  		y         *big.Int
   159  		expectedX *big.Int
   160  		expectedY *big.Int
   161  	}{
   162  		{
   163  			r:         types.StrToBig("2458502865976494910213617956670505342647705497324144349552978333078363662855"),
   164  			x:         types.StrToBig("1468732614996758835380505372879805860898778283940581072611506469031548393285"),
   165  			y:         types.StrToBig("1402551897475685522592936265087340527872184619899218186422141407423956771926"),
   166  			expectedX: types.StrToBig("182543067952221301675635959482860590467161609552169396182763685292434699999"),
   167  			expectedY: types.StrToBig("3154881600662997558972388646773898448430820936643060392452233533274798056266"),
   168  		},
   169  	}
   170  
   171  	for _, tt := range testMult {
   172  		x, y, err := Curve.MimicEcMultAir(tt.r, tt.x, tt.y, Curve.Gx, Curve.Gy)
   173  		if err != nil {
   174  			t.Errorf("MultAirERR %v\n", err)
   175  		}
   176  
   177  		if x.Cmp(tt.expectedX) != 0 {
   178  			t.Errorf("ResX %v does not == expected %v\n", x, tt.expectedX)
   179  
   180  		}
   181  		if y.Cmp(tt.expectedY) != 0 {
   182  			t.Errorf("ResY %v does not == expected %v\n", y, tt.expectedY)
   183  		}
   184  	}
   185  }