diff --git a/diffieHellman/dhkx.go b/diffieHellman/dhkx.go
index a1aabdefd1a2107621dcc8ab837d00f9c7289438..bfa664f20b6261b120407957adfd29039182532d 100644
--- a/diffieHellman/dhkx.go
+++ b/diffieHellman/dhkx.go
@@ -11,15 +11,13 @@ import (
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/crypto/csprng"
"gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/crypto/large"
)
// CreateDHKeyPair is a function that receives the generator and prime and
// returns a Diffie-Hellman Key pair withing the group
func CreateDHKeyPair(group *cyclic.Group) (*cyclic.Int, *cyclic.Int) {
-
- prime := group.GetP(cyclic.NewInt(0))
-
- if !prime.IsPrime() {
+ if !group.GetP().IsPrime() {
jww.FATAL.Panicf("CreateDHKeyPair(): Passed number is not prime")
}
@@ -36,10 +34,10 @@ func CreateDHKeyPair(group *cyclic.Group) (*cyclic.Int, *cyclic.Int) {
panic(fmt.Sprintf("Key RNG in Diffie Hellman Failed: %s", err.Error()))
}
- privateKey := cyclic.NewIntFromBytes(k1)
+ privateKey := group.NewIntFromBytes(k1)
- publicKey := cyclic.NewInt(0)
- publicKey.Exp(group.G, privateKey, prime)
+ publicKey := group.NewInt(0)
+ group.Exp(group.GetGCyclic(), privateKey, publicKey)
return privateKey, publicKey
}
@@ -49,11 +47,8 @@ func CreateDHKeyPair(group *cyclic.Group) (*cyclic.Int, *cyclic.Int) {
// v1.0 still does not include the CheckPublicKeyFeature
func CreateDHSessionKey(publicKey *cyclic.Int, privateKey *cyclic.Int,
group *cyclic.Group) (*cyclic.Int, error) {
-
- prime := group.GetP(cyclic.NewInt(0))
-
- sessionKey := cyclic.NewInt(0)
- sessionKey.Exp(publicKey, privateKey, prime)
+ sessionKey := group.NewInt(0)
+ group.Exp(publicKey, privateKey, sessionKey)
return sessionKey, nil
}
@@ -63,34 +58,26 @@ func CreateDHSessionKey(publicKey *cyclic.Int, privateKey *cyclic.Int,
// A valid public key will never trigger a negative response from this function
// Legendre Symbol = a^(p-1)/2 mod p
func CheckPublicKey(group *cyclic.Group, publicKey *cyclic.Int) bool {
-
- prime := cyclic.NewInt(0)
- group.GetP(prime)
-
// Definition of the lower bound to 1
- lowerBound := cyclic.NewInt(1)
+ lowerBound := large.NewInt(1)
// Definition of the upper bound to p-1
- upperBound := cyclic.NewInt(0)
- group.GetPSub1(upperBound)
+ upperBound := group.GetPSub1()
//Cmp returns -1 if number is smaller, 0 if the same and 1 if bigger than.
- x := publicKey.Cmp(lowerBound)
- y := publicKey.Cmp(upperBound)
+ x := publicKey.GetLargeInt().Cmp(lowerBound)
+ y := publicKey.GetLargeInt().Cmp(upperBound)
// Public Key must be bigger than 1 and smaller than p-1
if x != 1 || y != -1 {
return false
}
- z := cyclic.NewInt(0)
- z.Div(upperBound, cyclic.NewInt(2))
-
- symbol := cyclic.NewInt(0)
- symbol.Exp(publicKey, z, prime)
+ symbol := group.NewInt(0)
+ group.Exp(publicKey, group.GetPSub1FactorCyclic(), symbol)
// Symbol must be equal to 1
- if symbol.Cmp(lowerBound) == 0 {
+ if symbol.GetLargeInt().Cmp(lowerBound) == 0 {
return true
} else {
return false
diff --git a/diffieHellman/dhkx_test.go b/diffieHellman/dhkx_test.go
index e6a5312a2267628ca3dab7c50e89c7ff0a8ea86f..7448d5248faef49e71fd5f7e0bf835aa97b0b5c7 100644
--- a/diffieHellman/dhkx_test.go
+++ b/diffieHellman/dhkx_test.go
@@ -9,6 +9,7 @@ package diffieHellman
import (
"encoding/hex"
"gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/crypto/large"
"testing"
)
@@ -30,14 +31,15 @@ func TestDHKX(t *testing.T) {
"E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9" +
"DE2BCBF6955817183995497CEA956AE515D2261898FA0510" +
"15728E5A8AACAA68FFFFFFFFFFFFFFFF"
- p := cyclic.NewInt(0)
+ p := large.NewInt(0)
p.SetString(primeString, 16)
- g := cyclic.NewInt(2)
- s := cyclic.NewInt(0)
- min := cyclic.NewInt(2)
+ g := large.NewInt(2)
+ q := large.NewInt(3)
+ s := large.NewInt(0)
+ min := large.NewInt(2)
max := p
rng := cyclic.NewRandom(min, max)
- grp := cyclic.NewGroup(p, s, g, rng)
+ grp := cyclic.NewGroup(p, s, g, q, rng)
testGroup := &grp
// Creation of two different DH Key Pairs with valid parameters
@@ -45,7 +47,7 @@ func TestDHKX(t *testing.T) {
privKey2, pubKey2 := CreateDHKeyPair(testGroup)
// Check if Public Key is within the group
- if pubKey.Cmp(p) != -1 {
+ if !grp.Inside(pubKey) {
t.Errorf("TestNewDHKeyPair(): Public Key is bigger than the prime!")
} else {
pass++
@@ -56,14 +58,14 @@ func TestDHKX(t *testing.T) {
sessionKey2, _ := CreateDHSessionKey(pubKey2, privKey, testGroup)
// Comparison of Two Session Keys (0 means they are equal)
- if sessionKey1.Cmp(sessionKey2) != 0 {
+ if sessionKey1.GetLargeInt().Cmp(sessionKey2.GetLargeInt()) != 0 {
t.Errorf("TestDHKX(): Error in CreateDHSessionKey() -> Session Keys do not match!")
} else {
pass++
}
// Check if Session Key is within the prime group
- if sessionKey1.Cmp(p) != -1 {
+ if !grp.Inside(sessionKey1) {
t.Errorf("TestNewDHKeyPair(): Session Key is bigger than the prime!")
} else {
pass++
@@ -84,14 +86,15 @@ func Catch(fn string, t *testing.T) {
// TestCreateDHKeyPair checks if panic is triggered when passing a number that is not a prime
func TestCreateDHKeyPair(t *testing.T) {
- p := cyclic.NewInt(4)
- g := cyclic.NewInt(2)
- s := cyclic.NewInt(0)
- min := cyclic.NewInt(2)
+ p := large.NewInt(4)
+ g := large.NewInt(2)
+ q := large.NewInt(3)
+ s := large.NewInt(0)
+ min := large.NewInt(2)
max := p
rng := cyclic.NewRandom(min, max)
- grp := cyclic.NewGroup(p, s, g, rng)
+ grp := cyclic.NewGroup(p, s, g, q, rng)
testGroup := &grp
defer Catch("TestCreateDHKeyPair():", t)
@@ -114,15 +117,16 @@ func TestCheckPublicKey(t *testing.T) {
"E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9" +
"DE2BCBF6955817183995497CEA956AE515D2261898FA0510" +
"15728E5A8AACAA68FFFFFFFFFFFFFFFF"
- p := cyclic.NewInt(0)
+ p := large.NewInt(0)
p.SetString(primeString, 16)
- g := cyclic.NewInt(2)
- s := cyclic.NewInt(0)
- min := cyclic.NewInt(2)
+ g := large.NewInt(2)
+ q := large.NewInt(3)
+ s := large.NewInt(0)
+ min := large.NewInt(2)
max := p
rng := cyclic.NewRandom(min, max)
- grp := cyclic.NewGroup(p, s, g, rng)
+ grp := cyclic.NewGroup(p, s, g, q, rng)
testGroup := &grp
// Creation of a DH Key Pair with valid parameters
@@ -139,10 +143,10 @@ func TestCheckPublicKey(t *testing.T) {
"0a34a6954938d29fd24a72aae3d4a0c2873ed4"
a, _ := hex.DecodeString(randomNum)
- x := cyclic.NewIntFromBytes(a)
+ x := grp.NewIntFromBytes(a)
rightSymbol := CheckPublicKey(testGroup, pubKey)
- fakeSymbol := CheckPublicKey(testGroup, cyclic.NewInt(1))
+ fakeSymbol := CheckPublicKey(testGroup, grp.NewInt(1))
falseSymbol := CheckPublicKey(testGroup, x)
if rightSymbol {
@@ -183,15 +187,16 @@ func TestDHNodeKeys(t *testing.T) {
"E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9" +
"DE2BCBF6955817183995497CEA956AE515D2261898FA0510" +
"15728E5A8AACAA68FFFFFFFFFFFFFFFF"
- p := cyclic.NewInt(0)
+ p := large.NewInt(0)
p.SetString(primeString, 16)
- g := cyclic.NewInt(2)
- s := cyclic.NewInt(0)
- min := cyclic.NewInt(2)
+ g := large.NewInt(2)
+ q := large.NewInt(3)
+ s := large.NewInt(0)
+ min := large.NewInt(2)
max := p
rng := cyclic.NewRandom(min, max)
- grp := cyclic.NewGroup(p, s, g, rng)
+ grp := cyclic.NewGroup(p, s, g, q, rng)
testGroup := &grp
// This is a map key(string) -> value (hex string)
@@ -237,30 +242,30 @@ func TestDHNodeKeys(t *testing.T) {
sk3, _ := hex.DecodeString(nodeDHPrivateKeys["3"])
// Keys between Node 1 & 2
- k12, _ := CreateDHSessionKey(cyclic.NewIntFromBytes(pk2), cyclic.NewIntFromBytes(sk1), testGroup)
- k21, _ := CreateDHSessionKey(cyclic.NewIntFromBytes(pk1), cyclic.NewIntFromBytes(sk2), testGroup)
+ k12, _ := CreateDHSessionKey(grp.NewIntFromBytes(pk2), grp.NewIntFromBytes(sk1), testGroup)
+ k21, _ := CreateDHSessionKey(grp.NewIntFromBytes(pk1), grp.NewIntFromBytes(sk2), testGroup)
// Keys between Node 1 & 3
- k13, _ := CreateDHSessionKey(cyclic.NewIntFromBytes(pk1), cyclic.NewIntFromBytes(sk3), testGroup)
- k31, _ := CreateDHSessionKey(cyclic.NewIntFromBytes(pk3), cyclic.NewIntFromBytes(sk1), testGroup)
+ k13, _ := CreateDHSessionKey(grp.NewIntFromBytes(pk1), grp.NewIntFromBytes(sk3), testGroup)
+ k31, _ := CreateDHSessionKey(grp.NewIntFromBytes(pk3), grp.NewIntFromBytes(sk1), testGroup)
// Keys between Node 2 & 3
- k23, _ := CreateDHSessionKey(cyclic.NewIntFromBytes(pk2), cyclic.NewIntFromBytes(sk3), testGroup)
- k32, _ := CreateDHSessionKey(cyclic.NewIntFromBytes(pk3), cyclic.NewIntFromBytes(sk2), testGroup)
+ k23, _ := CreateDHSessionKey(grp.NewIntFromBytes(pk2), grp.NewIntFromBytes(sk3), testGroup)
+ k32, _ := CreateDHSessionKey(grp.NewIntFromBytes(pk3), grp.NewIntFromBytes(sk2), testGroup)
- if k12.Cmp(k21) != 0 {
+ if k12.GetLargeInt().Cmp(k21.GetLargeInt()) != 0 {
t.Errorf("Keys between Node 1 & 2 do not match!")
} else {
pass++
}
- if k13.Cmp(k31) != 0 {
+ if k13.GetLargeInt().Cmp(k31.GetLargeInt()) != 0 {
t.Errorf("Keys between Node 1 & 3 do not match!")
} else {
pass++
}
- if k23.Cmp(k32) != 0 {
+ if k23.GetLargeInt().Cmp(k32.GetLargeInt()) != 0 {
t.Errorf("Keys between Node 2 & 3 do not match!")
} else {
pass++
diff --git a/e2e/aes_test.go b/e2e/aes_test.go
index 79db8ade1b7039811676662954750f8aa6cc7b18..4e0672a95c077edfedc92b26cb4745a987b3f51c 100644
--- a/e2e/aes_test.go
+++ b/e2e/aes_test.go
@@ -11,6 +11,7 @@ import (
"encoding/hex"
"gitlab.com/elixxir/crypto/csprng"
"gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/crypto/large"
"testing"
)
@@ -249,9 +250,9 @@ func TestEncDecAES_BadKey(t *testing.T) {
// Test AES encryption with various arguments
func TestEncAES_Args(t *testing.T) {
keys := [][]byte{
- cyclic.NewIntFromString(TEST_KEY_256, 16).Bytes(),
- cyclic.NewIntFromString(TEST_KEY_248, 16).Bytes(),
- cyclic.NewIntFromString(TEST_KEY_128, 16).Bytes(),
+ large.NewIntFromString(TEST_KEY_256, 16).Bytes(),
+ large.NewIntFromString(TEST_KEY_248, 16).Bytes(),
+ large.NewIntFromString(TEST_KEY_128, 16).Bytes(),
[]byte(""),
nil,
}
@@ -296,7 +297,7 @@ func TestDecAES_Args(t *testing.T) {
}
keys := [][]byte{
- cyclic.NewIntFromString(TEST_KEY_256, 16).Bytes(),
+ large.NewIntFromString(TEST_KEY_256, 16).Bytes(),
[]byte(""),
nil}
@@ -395,9 +396,9 @@ func TestAESEnc_Hash(t *testing.T) {
// Loop test AES encryption/decryption with random inputs
func TestEncDecAES_Random(t *testing.T) {
- keyGen := cyclic.NewRandom(cyclic.NewInt(28), cyclic.NewInt(512))
- textGen := cyclic.NewRandom(cyclic.NewInt(1), cyclic.NewInt(4096))
- randSize := cyclic.NewInt(1)
+ keyGen := cyclic.NewRandom(large.NewInt(28), large.NewInt(512))
+ textGen := cyclic.NewRandom(large.NewInt(1), large.NewInt(4096))
+ randSize := large.NewInt(1)
tests := NUM_TESTS
pass := 0
diff --git a/e2e/dummykeygen.go b/e2e/dummykeygen.go
index 48a40347bfa8de175c6f9c0e0d48e837596e5c3a..9d788943b5d7435a7ca1e57d749e06e61d475799 100644
--- a/e2e/dummykeygen.go
+++ b/e2e/dummykeygen.go
@@ -31,7 +31,7 @@ func combinedHash(userA *id.User, userB *id.User, grp *cyclic.Group) *cyclic.Int
expKey := hash.ExpandKey(h, grp, combKey)
- return cyclic.NewIntFromBytes(expKey)
+ return grp.NewIntFromBytes(expKey)
}
diff --git a/e2e/dummykeygen_test.go b/e2e/dummykeygen_test.go
index b082adfc7a463c05c4b6464703b8c2085ca9215b..54bee94f382cfc626d5bc387c77e0d724b8f2059 100644
--- a/e2e/dummykeygen_test.go
+++ b/e2e/dummykeygen_test.go
@@ -57,7 +57,7 @@ func TestDummyKeyGen_KeysMatch(t *testing.T) {
l := len(keys1)
for i, v := range keys1 {
- if v.Cmp(keys2[l-i-1]) != 0 {
+ if v.GetLargeInt().Cmp(keys2[l-i-1].GetLargeInt()) != 0 {
t.Errorf("Key mismatch")
}
}
@@ -75,7 +75,7 @@ func TestDummyKeyGen_CombinedHashCommutes(t *testing.T) {
res2 := combinedHash(userB, userA, &grp)
- if res1.Cmp(res2) != 0 {
+ if res1.GetLargeInt().Cmp(res2.GetLargeInt()) != 0 {
t.Errorf("Combined hash order should not matter")
}
}
diff --git a/e2e/encrypt.go b/e2e/encrypt.go
index 6d8bb2cda321b5c9b2cce94bb3bce18232285723..2d2e05a2e8e9dd3c3f52447576acf716a5c9c5c9 100644
--- a/e2e/encrypt.go
+++ b/e2e/encrypt.go
@@ -24,7 +24,7 @@ func encrypt(g cyclic.Group, key *cyclic.Int, msg []byte,
}
// Modular multiply the key with the padded message
- product := g.Mul(key, cyclic.NewIntFromBytes(encMsg), cyclic.NewInt(0))
+ product := g.Mul(key, g.NewIntFromBytes(encMsg), g.NewInt(0))
// Return the result
return product.LeftpadBytes(uint64(format.TOTAL_LEN)), nil
@@ -34,10 +34,10 @@ func encrypt(g cyclic.Group, key *cyclic.Int, msg []byte,
// the encrypted message under the passed group.
func Decrypt(g cyclic.Group, key *cyclic.Int, encMsg []byte) ([]byte, error) {
// Modular invert the key under the group
- keyInv := g.Inverse(key, cyclic.NewInt(0))
+ keyInv := g.Inverse(key, g.NewInt(0))
// Modular multiply the inverted key with the message
- product := g.Mul(keyInv, cyclic.NewIntFromBytes(encMsg), cyclic.NewInt(0))
+ product := g.Mul(keyInv, g.NewIntFromBytes(encMsg), g.NewInt(0))
// Remove the padding from the message
unPadMsg, err := Unpad(product.LeftpadBytes(uint64(format.TOTAL_LEN)))
diff --git a/e2e/encrypt_test.go b/e2e/encrypt_test.go
index 5389bff7745dd3d9adbca191bd40491a903f61f6..978802705ceb1328b04e3b22cabb5716fbf3d1d3 100644
--- a/e2e/encrypt_test.go
+++ b/e2e/encrypt_test.go
@@ -4,6 +4,7 @@ import (
b64 "encoding/base64"
"errors"
"gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/crypto/large"
"math/rand"
"os"
"reflect"
@@ -26,14 +27,15 @@ func TestMain(m *testing.M) {
"E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9" +
"DE2BCBF6955817183995497CEA956AE515D2261898FA0510" +
"15728E5A8AACAA68FFFFFFFFFFFFFFFF"
- p := cyclic.NewIntFromString(primeString, 16)
- min := cyclic.NewInt(2)
- max := cyclic.NewInt(0)
- max.Mul(p, cyclic.NewInt(1000))
- seed := cyclic.NewInt(42)
+ p := large.NewIntFromString(primeString, 16)
+ min := large.NewInt(2)
+ max := large.NewInt(0)
+ max.Mul(p, large.NewInt(1000))
+ seed := large.NewInt(42)
rng := cyclic.NewRandom(min, max)
- g := cyclic.NewInt(2)
- grp = cyclic.NewGroup(p, seed, g, rng)
+ g := large.NewInt(2)
+ q := large.NewInt(3)
+ grp = cyclic.NewGroup(p, seed, g, q, rng)
os.Exit(m.Run())
}
@@ -42,7 +44,7 @@ func TestMain(m *testing.M) {
// and check that it is the same when decrypting
func TestEncryptDecrypt(t *testing.T) {
// Create key and message
- key := cyclic.NewInt(3)
+ key := grp.NewInt(3)
msg := []byte{5, 12, 11}
// Encrypt key
@@ -64,7 +66,7 @@ func TestEncryptDecrypt(t *testing.T) {
func TestEncryptDecrypt_LeadingZeroes(t *testing.T) {
// Create key and message
- key := cyclic.NewInt(3)
+ key := grp.NewInt(3)
msg := []byte{0, 0, 11, 5, 255, 0}
// Encrypt key
@@ -111,7 +113,7 @@ func TestEncrypt_Consistency(t *testing.T) {
rand.Seed(3102644637)
msgBytes := make([]byte, 40)
for i := 0; i < 16; i++ {
- keys = append(keys, cyclic.NewInt(keyPrng.Int63()))
+ keys = append(keys, grp.NewInt(keyPrng.Int63()))
rand.Read(msgBytes)
msgs = append(msgs, msgBytes)
}
@@ -141,7 +143,7 @@ func TestEncrypt_ErrorOnLongMessage(t *testing.T) {
msgBytes := make([]byte, 4000)
rand.Read(msgBytes)
msg := msgBytes
- key := cyclic.NewInt(65)
+ key := grp.NewInt(65)
// Encrypt key
encMsg, err := Encrypt(grp, key, msg)
@@ -162,7 +164,7 @@ func TestDecrypt_ErrorOnPaddingPrefix(t *testing.T) {
msgBytes := make([]byte, 40)
rand.Read(msgBytes)
msg := msgBytes
- key := cyclic.NewInt(65)
+ key := grp.NewInt(65)
// Decrypt key
dncMsg, err := Decrypt(grp, key, msg)
diff --git a/e2e/keygen.go b/e2e/keygen.go
index 673cbfca94816b669876b727f76220b00abbf216..4688cd53e2acc3753998b36adff7745371dce45d 100644
--- a/e2e/keygen.go
+++ b/e2e/keygen.go
@@ -17,5 +17,5 @@ import (
// TODO: Implement the proper keygen once defined
func Keygen(g *cyclic.Group, salt, basekey *cyclic.Int) *cyclic.Int {
jww.WARN.Printf("End to End Encryption is not fully implemented, Keygen is not secure")
- return cyclic.NewInt(1)
+ return g.NewInt(1)
}
\ No newline at end of file
diff --git a/e2e/keygen_test.go b/e2e/keygen_test.go
index 8c20f3de69f750e5119968a11c31f74ca7f7bce7..b616160a083c1457d8801a907108b4aeaed49e56 100644
--- a/e2e/keygen_test.go
+++ b/e2e/keygen_test.go
@@ -8,6 +8,7 @@ package e2e
import (
"gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/crypto/large"
"testing"
)
@@ -24,21 +25,22 @@ func TestKeygen(t *testing.T) {
"DE2BCBF6955817183995497CEA956AE515D2261898FA0510" +
"15728E5A8AACAA68FFFFFFFFFFFFFFFF"
- p := cyclic.NewIntFromString(primeString, 16)
- min := cyclic.NewInt(2)
- max := cyclic.NewInt(0)
- max.Mul(p, cyclic.NewInt(1000))
- seed := cyclic.NewInt(42)
+ p := large.NewIntFromString(primeString, 16)
+ min := large.NewInt(2)
+ max := large.NewInt(0)
+ max.Mul(p, large.NewInt(1000))
+ seed := large.NewInt(42)
rng := cyclic.NewRandom(min, max)
- g := cyclic.NewInt(2)
- grp := cyclic.NewGroup(p, seed, g, rng)
+ g := large.NewInt(2)
+ q := large.NewInt(3)
+ grp := cyclic.NewGroup(p, seed, g, q, rng)
testGroup := &grp
- salt := cyclic.NewInt(1)
- basekey := cyclic.NewInt(1)
+ salt := grp.NewInt(1)
+ basekey := grp.NewInt(1)
key := Keygen(testGroup, salt, basekey)
- if key.Cmp(salt) != 0 {
+ if key.GetLargeInt().Cmp(salt.GetLargeInt()) != 0 {
t.Errorf("Dummy keygen should return 1")
}
}
\ No newline at end of file
diff --git a/e2e/keys.go b/e2e/keys.go
index 658aba67e2f6642f011f82b496716a899dc938c4..853457fc09aa381916700d64de7a26d7b0409d91 100644
--- a/e2e/keys.go
+++ b/e2e/keys.go
@@ -19,7 +19,7 @@ func deriveSingleKey(h hash.Hash, g *cyclic.Group, data []byte, id uint) *cyclic
b, _ := hash2.NewCMixHash()
b.Write(data)
b.Write(idBytes[:n])
- return cyclic.NewIntFromBytes(hash2.ExpandKey(h, g, b.Sum(nil)))
+ return g.NewIntFromBytes(hash2.ExpandKey(h, g, b.Sum(nil)))
}
// This function derives multiple keys using the specified hash function
diff --git a/e2e/keys_test.go b/e2e/keys_test.go
index 2b9815ec10668904322d7433a60a7f04160e2197..dd180528e8849843c5e011be8ebf931b531d7f61 100644
--- a/e2e/keys_test.go
+++ b/e2e/keys_test.go
@@ -35,13 +35,14 @@ type testFun func(a *cyclic.Group, b *cyclic.Int, c *id.User, d uint) []*cyclic.
// Test for consistency with hardcoded values
func TestDeriveSingleKey(t *testing.T) {
userID := id.NewUserFromUint(TEST_USERID, t)
- key := cyclic.NewIntFromString(TEST_DHKEY, 16)
+ key := grp.NewIntFromString(TEST_DHKEY, 16)
data := append([]byte{}, key.Bytes()...)
data = append(data, userID.Bytes()...)
result := deriveSingleKey(sha256.New(), &grp, data, 0)
- expected := cyclic.NewIntFromString(EXPECTED_KEY, 16)
- if result.Cmp(expected) != 0 {
- t.Errorf("Generated Key %v doesn't match expected %v", result.Text(16), EXPECTED_KEY)
+ expected := grp.NewIntFromString(EXPECTED_KEY, 16)
+ if result.GetLargeInt().Cmp(expected.GetLargeInt()) != 0 {
+ t.Errorf("Generated Key %v doesn't match expected %v",
+ result.GetLargeInt().Text(16), EXPECTED_KEY)
}
}
@@ -49,7 +50,7 @@ func TestDeriveSingleKey(t *testing.T) {
func TestDeriveKeys_DeriveEmergencyKeys(t *testing.T) {
userID := id.NewUserFromUint(TEST_USERID, t)
partnerID := id.NewUserFromUint(TEST_PARTNERID, t)
- key := cyclic.NewIntFromString(TEST_DHKEY, 16)
+ key := grp.NewIntFromString(TEST_DHKEY, 16)
nkeys := []uint{10000, 0}
total := func(a []uint) (s int) {
@@ -107,7 +108,7 @@ func TestDeriveKeys_DeriveEmergencyKeys(t *testing.T) {
// Test both functions with same arguments to explicitly show they produce different keys
func TestDeriveKeys_DeriveEmergencyKeys_Differ(t *testing.T) {
userID := id.NewUserFromUint(TEST_USERID, t)
- key := cyclic.NewIntFromString(TEST_DHKEY, 16)
+ key := grp.NewIntFromString(TEST_DHKEY, 16)
nkeys := uint(100)
fut := []testFun{DeriveKeys, DeriveEmergencyKeys}
var genKeys = make([][]*cyclic.Int, len(fut))
@@ -125,7 +126,7 @@ func TestDeriveKeys_DeriveEmergencyKeys_Differ(t *testing.T) {
// Directly compare each key
for i:=0; i<int(nkeys); i++ {
- if genKeys[0][i].Cmp(genKeys[1][i]) == 0 {
+ if genKeys[0][i].GetLargeInt().Cmp(genKeys[1][i].GetLargeInt()) == 0 {
t.Errorf("Keys are the same when generated with different functions")
}
}
diff --git a/e2e/ttl.go b/e2e/ttl.go
index 3a48e7dd1936296bff44c6cd4c6bc2ffdf052d59..c67a255a8e5fc4bd2eedfbe3e6cc6cdd8a36d47c 100644
--- a/e2e/ttl.go
+++ b/e2e/ttl.go
@@ -2,8 +2,8 @@ package e2e
import (
jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/crypto/cyclic"
"gitlab.com/elixxir/crypto/hash"
+ "gitlab.com/elixxir/crypto/large"
"math"
)
@@ -14,7 +14,7 @@ type TTLParams struct {
// Generates Key TTL and num keys given a key and a range.
// Returns fair key TTL (num keys before retrigger happens) and num keys (usage capacity)
-func GenerateKeyTTL(key *cyclic.Int, min uint16, max uint16, params TTLParams) (uint16, uint32) {
+func GenerateKeyTTL(key large.Int, min uint16, max uint16, params TTLParams) (uint16, uint32) {
h, err := hash.NewCMixHash()
@@ -43,9 +43,9 @@ func computeTTL(hashed []byte, min uint16, max uint16) uint16 {
jww.ERROR.Panicf("Min must be greater than or equal to max in computeTTL")
}
- zero := cyclic.NewInt(0)
- keyHash := cyclic.NewIntFromBytes(hashed)
- mod := cyclic.NewInt(int64(max - min))
+ zero := large.NewInt(0)
+ keyHash := large.NewIntFromBytes(hashed)
+ mod := large.NewInt(int64(max - min))
// The formula used is: ttl = (keyHash % mod) + min | s.t. mod = (max - min)
ttl := uint16(zero.Mod(keyHash, mod).Int64()) + min
diff --git a/e2e/ttl_test.go b/e2e/ttl_test.go
index 03fe6139679a137644e1e6b56f05008d769d4c61..a51d8455b8344641f50e2a5993261e6b08208101 100644
--- a/e2e/ttl_test.go
+++ b/e2e/ttl_test.go
@@ -7,7 +7,7 @@
package e2e
import (
- "gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/crypto/large"
"testing"
)
@@ -20,7 +20,7 @@ func TestGenerateKeyTTL_PanicOnMinMaxEq(t *testing.T) {
}
}()
- sessionKey := *cyclic.NewInt(23)
+ sessionKey := large.NewInt(23)
min := uint16(200)
max := uint16(200)
@@ -30,7 +30,7 @@ func TestGenerateKeyTTL_PanicOnMinMaxEq(t *testing.T) {
400,
}
- GenerateKeyTTL(&sessionKey, min, max, params)
+ GenerateKeyTTL(sessionKey, min, max, params)
}
// Verify GenerateKeyTTL panics when min is greater than max
@@ -42,7 +42,7 @@ func TestGenerateKeyTTL_PanicOnMinGreaterThanMax(t *testing.T) {
}
}()
- sessionKey := *cyclic.NewInt(23)
+ sessionKey := large.NewInt(23)
min := uint16(2000)
max := uint16(200)
@@ -52,13 +52,13 @@ func TestGenerateKeyTTL_PanicOnMinGreaterThanMax(t *testing.T) {
400,
}
- GenerateKeyTTL(&sessionKey, min, max, params)
+ GenerateKeyTTL(sessionKey, min, max, params)
}
// Verify GenerateKeyTTL generated expected TTL and NumKeys
func TestGenerateKeyTTL_ValidTTL(t *testing.T) {
- sessionKey := *cyclic.NewInt(23)
+ sessionKey := large.NewInt(23)
min := uint16(2000)
max := uint16(20000)
@@ -68,7 +68,7 @@ func TestGenerateKeyTTL_ValidTTL(t *testing.T) {
400,
}
- ttl, numKeys := GenerateKeyTTL(&sessionKey, min, max, params)
+ ttl, numKeys := GenerateKeyTTL(sessionKey, min, max, params)
expectedTTL := uint16(8115)
expectedNumKeys := uint32(9738)
@@ -109,7 +109,7 @@ func TestGenerateKeyTTL_KeysPerTimeEqZeroShouldPanic(t *testing.T) {
}
}()
- sessionKey := *cyclic.NewInt(23)
+ sessionKey := large.NewInt(23)
min := uint16(20)
max := uint16(200)
@@ -119,7 +119,7 @@ func TestGenerateKeyTTL_KeysPerTimeEqZeroShouldPanic(t *testing.T) {
400,
}
- GenerateKeyTTL(&sessionKey, min, max, params)
+ GenerateKeyTTL(sessionKey, min, max, params)
}
// TTL scalar should never be negative
@@ -130,7 +130,7 @@ func TestGenerateKeyTTL_KeysPerTimeIsLessThanZeroShouldPanic(t *testing.T) {
}
}()
- sessionKey := *cyclic.NewInt(23)
+ sessionKey := large.NewInt(23)
min := uint16(20)
max := uint16(200)
@@ -140,5 +140,5 @@ func TestGenerateKeyTTL_KeysPerTimeIsLessThanZeroShouldPanic(t *testing.T) {
400,
}
- GenerateKeyTTL(&sessionKey, min, max, params)
+ GenerateKeyTTL(sessionKey, min, max, params)
}
diff --git a/hash/keys.go b/hash/keys.go
index 47a1c88fc27645814046a15e0fc432730cab4778..f19d83895c2f2beb78c867fc23111e6b5a8dd611 100644
--- a/hash/keys.go
+++ b/hash/keys.go
@@ -22,15 +22,15 @@ func ExpandKey(h hash.Hash, g *cyclic.Group, key []byte) []byte {
return h
}
keyGen := hkdf.Expand(foo, key, nil)
- keyInt := cyclic.NewInt(0)
- expandedKey := make([]byte, g.GetP(nil).BitLen()>>3)
+ keyInt := g.NewInt(0)
+ expandedKey := make([]byte, g.GetP().BitLen()>>3)
// Make sure generated key is in the group
for !g.Inside(keyInt) {
size, err := keyGen.Read(expandedKey)
if err != nil || size != len(expandedKey) {
jww.FATAL.Panicf("Could not expand key: %v", err.Error())
}
- keyInt.SetBytes(expandedKey)
+ keyInt.GetLargeInt().SetBytes(expandedKey)
}
return expandedKey
}
diff --git a/hash/keys_test.go b/hash/keys_test.go
index 2e50453415bdfbb4006ccd5dcc9640f43da8fb12..4a483a6f0542b694b8e3ab71caa482ccae55b74e 100644
--- a/hash/keys_test.go
+++ b/hash/keys_test.go
@@ -10,6 +10,7 @@ import (
"crypto/sha512"
"encoding/hex"
"gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/crypto/large"
"testing"
)
@@ -25,13 +26,14 @@ var primeString = "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1" +
"DE2BCBF6955817183995497CEA956AE515D2261898FA0510" +
"15728E5A8AACAA68FFFFFFFFFFFFFFFF"
-var p = cyclic.NewIntFromString(primeString, 16)
-var min = cyclic.NewInt(2)
-var max = cyclic.NewInt(0)
-var seed = cyclic.NewInt(42)
-var rng = cyclic.NewRandom(min, max.Mul(p, cyclic.NewInt(1000)))
-var g = cyclic.NewInt(2)
-var grp = cyclic.NewGroup(p, seed, g, rng)
+var p = large.NewIntFromString(primeString, 16)
+var min = large.NewInt(2)
+var max = large.NewInt(0)
+var seed = large.NewInt(42)
+var rng = cyclic.NewRandom(min, max.Mul(p, large.NewInt(1000)))
+var g = large.NewInt(2)
+var q = large.NewInt(3)
+var grp = cyclic.NewGroup(p, seed, g, q, rng)
//TestExpandKey verifies ExpandKey with two different hashes
func TestExpandKey(t *testing.T) {
diff --git a/messaging/key.go b/messaging/key.go
index c70a83d4ad296f0e8b28aecdf5c9dafaff865321..8cf69ff77839b496caca96a82382c73812c80dd9 100644
--- a/messaging/key.go
+++ b/messaging/key.go
@@ -54,7 +54,7 @@ func NewDecryptionKey(salt []byte, baseKey *cyclic.Int, group *cyclic.Group) *cy
// Use SHA512
z := hash.ExpandKey(sha512.New(), group, y)
- r := cyclic.NewIntFromBytes(z)
+ r := group.NewIntFromBytes(z)
return r
}
diff --git a/messaging/key_test.go b/messaging/key_test.go
index 65955ad8d2316be4170103f9a2dc1117a7cd38a4..709328b0c508d8238a83c0ffd08ebe30f45ba0bf 100644
--- a/messaging/key_test.go
+++ b/messaging/key_test.go
@@ -8,6 +8,7 @@ package messaging
import (
"gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/crypto/large"
"testing"
)
@@ -33,12 +34,12 @@ var primeStrng = "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1" +
"1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9" +
"93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934063199" +
"FFFFFFFFFFFFFFFF"
-var prime = cyclic.NewIntFromString(primeStrng, 16)
-var rng = cyclic.NewRandom(cyclic.NewInt(0),
- cyclic.NewIntFromString(primeStrng, 16))
-var grp = cyclic.NewGroup(prime, cyclic.NewInt(5), cyclic.NewInt(4),
+var prime = large.NewIntFromString(primeStrng, 16)
+var rng = cyclic.NewRandom(large.NewInt(0),
+ large.NewIntFromString(primeStrng, 16))
+var grp = cyclic.NewGroup(prime, large.NewInt(5), large.NewInt(4), large.NewInt(3),
rng)
-var baseKey = cyclic.NewIntFromString("a906df88f30d6afbfa6165a50cc9e208d16b34e70b367068dc5d6bd6e155b2c3", 16)
+var baseKey = grp.NewIntFromString("a906df88f30d6afbfa6165a50cc9e208d16b34e70b367068dc5d6bd6e155b2c3", 16)
var salt = []byte("fdecfa52a8ad1688dbfa7d16df74ebf27e535903c469cefc007ebbe1ee895064")
var expectStr = "2e4c99e14e0b1cd18c08467c395a4d5c0eb594507595041a5cfa83eb2f5791f3" +
"db46c933040d4c9862b91539fb8bc75e0b84ed07dd6a760dda6baec8c5f3f119" +
@@ -60,29 +61,33 @@ var expectStr = "2e4c99e14e0b1cd18c08467c395a4d5c0eb594507595041a5cfa83eb2f5791f
// Test for functionality of NewDecryptionKey using pre-canned values
func TestNewDecryptionKey(t *testing.T) {
k := NewDecryptionKey(salt, baseKey, &grp)
- expected := cyclic.NewIntFromString(expectStr, 16)
+ expected := grp.NewIntFromString(expectStr, 16)
if k == nil {
t.Errorf("Error should have been triggered!")
}
- if k.Cmp(expected) != 0 {
- t.Errorf("Expected: %s, Got: %s", expected.Text(16), k.TextVerbose(16, 0))
+ if k.GetLargeInt().Cmp(expected.GetLargeInt()) != 0 {
+ t.Errorf("Expected: %s, Got: %s",
+ expected.GetLargeInt().Text(16),
+ k.GetLargeInt().TextVerbose(16, 0))
}
}
// Test for functionality of NewEncryptionKey using pre-canned values
func TestNewEncryptionKey(t *testing.T) {
k := NewEncryptionKey(salt, baseKey, &grp)
- expected := cyclic.NewIntFromString(expectStr, 16)
+ expected := grp.NewIntFromString(expectStr, 16)
grp.Inverse(expected, expected)
if k == nil {
t.Errorf("Error should have been triggered!")
}
- if k.Cmp(expected) != 0 {
- t.Errorf("Expected: %s, Got: %s", expected.Text(16), k.TextVerbose(16, 0))
+ if k.GetLargeInt().Cmp(expected.GetLargeInt()) != 0 {
+ t.Errorf("Expected: %s, Got: %s",
+ expected.GetLargeInt().Text(16),
+ k.GetLargeInt().TextVerbose(16, 0))
}
}
@@ -97,12 +102,12 @@ func makebaseKeys(size int) []*cyclic.Int {
// Test that multiple baseKeys return a slice of same size with correct results
func TestNewDecryptionKeys(t *testing.T) {
keys := NewDecryptionKeys(salt, makebaseKeys(10), &grp)
- expected := cyclic.NewIntFromString(expectStr, 16)
+ expected := grp.NewIntFromString(expectStr, 16)
if len(keys) != 10 {
t.Errorf("Bad length: expected 10, got %d", len(keys))
}
for i := range keys {
- if keys[i].Cmp(expected) != 0 {
+ if keys[i].GetLargeInt().Cmp(expected.GetLargeInt()) != 0 {
t.Errorf("Generated key incorrect!")
}
}
@@ -119,13 +124,13 @@ func TestNewDecryptionKeysEmpty(t *testing.T) {
// Test that multiple baseKeys return a slice of same size with correct results
func TestNewEncryptionKeys(t *testing.T) {
keys := NewEncryptionKeys(salt, makebaseKeys(10), &grp)
- expected := cyclic.NewIntFromString(expectStr, 16)
+ expected := grp.NewIntFromString(expectStr, 16)
grp.Inverse(expected, expected)
if len(keys) != 10 {
t.Errorf("Bad length: expected 10, got %d", len(keys))
}
for i := range keys {
- if keys[i].Cmp(expected) != 0 {
+ if keys[i].GetLargeInt().Cmp(expected.GetLargeInt()) != 0 {
t.Errorf("Generated key incorrect!")
}
}
diff --git a/registration/keygen.go b/registration/keygen.go
index bc10eeb0e78f1b97ea51f88d40d5cf1ce2041cfa..661f2ff5d18c108917ab964c4b49ab1363f6abaa 100644
--- a/registration/keygen.go
+++ b/registration/keygen.go
@@ -22,10 +22,10 @@ import (
func GenerateBaseKey(g *cyclic.Group, peerPubKey *signature.DSAPublicKey,
ownPrivKey *signature.DSAPrivateKey, h hash.Hash) *cyclic.Int {
- pubKey := peerPubKey.GetKey()
- privKey := ownPrivKey.GetKey()
+ pubKey := g.NewIntFromLargeInt(peerPubKey.GetKey())
+ privKey := g.NewIntFromLargeInt(ownPrivKey.GetKey())
sessionKey, _ := diffieHellman.CreateDHSessionKey(pubKey, privKey, g)
h.Write(sessionKey.Bytes())
- return cyclic.NewIntFromBytes(h.Sum(nil))
+ return g.NewIntFromBytes(h.Sum(nil))
}
diff --git a/registration/keygen_test.go b/registration/keygen_test.go
index 48601187cd79cca64554d6230146c23d7dbc5dc7..bcdfa88f88cea496627619fa4553796807aba444 100644
--- a/registration/keygen_test.go
+++ b/registration/keygen_test.go
@@ -11,6 +11,7 @@ import (
"gitlab.com/elixxir/crypto/csprng"
"gitlab.com/elixxir/crypto/cyclic"
"gitlab.com/elixxir/crypto/hash"
+ "gitlab.com/elixxir/crypto/large"
"gitlab.com/elixxir/crypto/signature"
"testing"
)
@@ -25,11 +26,14 @@ var grp cyclic.Group
func TestGenerateBaseKey(t *testing.T) {
dsaParams := signature.GetDefaultDSAParams()
p := dsaParams.GetP()
- min := cyclic.NewInt(2)
- max := cyclic.NewInt(0)
- max.Mul(p, cyclic.NewInt(1000))
- seed := cyclic.NewInt(42)
- grp = cyclic.NewGroup(p, seed, dsaParams.GetG(), cyclic.NewRandom(min, max))
+ min := large.NewInt(2)
+ max := large.NewInt(0)
+ max.Mul(p, large.NewInt(1000))
+ seed := large.NewInt(42)
+ grp = cyclic.NewGroup(p, seed,
+ dsaParams.GetG(),
+ dsaParams.GetQ(),
+ cyclic.NewRandom(min, max))
rng := csprng.NewSystemRNG()
ownPrivKey := dsaParams.PrivateKeyGen(rng)
@@ -44,7 +48,7 @@ func TestGenerateBaseKey(t *testing.T) {
b.Reset()
peerBaseTKey := GenerateBaseKey(&grp, ownPubKey, peerPrivKey, b)
- if ownBaseTKey.Cmp(peerBaseTKey) != 0 {
+ if ownBaseTKey.GetLargeInt().Cmp(peerBaseTKey.GetLargeInt()) != 0 {
t.Errorf("Generated Base Key using blake2b is different between own and peer")
t.Errorf("own: %x", ownBaseTKey.Bytes())
t.Errorf("peer: %x", peerBaseTKey.Bytes())
@@ -56,13 +60,13 @@ func TestGenerateBaseKey(t *testing.T) {
h.Reset()
peerBaseRKey := GenerateBaseKey(&grp, ownPubKey, peerPrivKey, h)
- if ownBaseRKey.Cmp(peerBaseRKey) != 0 {
+ if ownBaseRKey.GetLargeInt().Cmp(peerBaseRKey.GetLargeInt()) != 0 {
t.Errorf("Generated Base Key using sha256 is different between own and peer")
t.Errorf("own: %x", ownBaseRKey.Bytes())
t.Errorf("peer: %x", peerBaseRKey.Bytes())
}
- if ownBaseTKey.Cmp(ownBaseRKey) == 0 {
+ if ownBaseTKey.GetLargeInt().Cmp(ownBaseRKey.GetLargeInt()) == 0 {
t.Errorf("Generated Base Keys are the same")
}
}
diff --git a/registration/uidgen.go b/registration/uidgen.go
index 9cc07a9b7c37ad5d8918d7c30a0ad8150a043f01..d81a9372d9c9a37b14bb9c167945caa7f984a10c 100644
--- a/registration/uidgen.go
+++ b/registration/uidgen.go
@@ -1,6 +1,7 @@
package registration
import (
+ "fmt"
"gitlab.com/elixxir/crypto/signature"
"gitlab.com/elixxir/crypto/hash"
"gitlab.com/elixxir/primitives/id"
@@ -15,6 +16,7 @@ func GenUserID(pubKey *signature.DSAPublicKey, salt []byte) *id.User {
jww.ERROR.Panicf("PubKey and/or Salt are nil")
}
pubBytes := pubKey.GetKey().Bytes()
+ fmt.Printf("%x\n", pubBytes)
if len(pubBytes) == 0 || len(salt) == 0 {
jww.ERROR.Panicf("PubKey and/or Salt are empty")
}
diff --git a/registration/uidgen_test.go b/registration/uidgen_test.go
index 494d42e887d819b50ddea683a1e71caeb53f0e20..24ab059037d3855ba8adc5d29b1905886a324861 100644
--- a/registration/uidgen_test.go
+++ b/registration/uidgen_test.go
@@ -4,6 +4,7 @@ import (
"crypto/rand"
"encoding/hex"
"gitlab.com/elixxir/crypto/csprng"
+ "gitlab.com/elixxir/crypto/large"
"gitlab.com/elixxir/crypto/signature"
"testing"
)
@@ -54,12 +55,11 @@ func TestGenUserID_NilSalt(t *testing.T) {
// Test GenUserID panics with empty byte slice public key
func TestGenUserID_EmptyKey(t *testing.T) {
params := signature.NewDSAParams(rand.Reader, signature.L2048N256)
- privKey := params.PrivateKeyGen(rand.Reader)
- pubKey := privKey.PublicKeyGen()
+ pubKey := signature.ReconstructPublicKey(
+ params,
+ large.NewIntFromBytes([]byte("")))
salt := []byte("0123456789ABCDEF0123456789ABCDEF")
- pubKey.GetKey().SetBytes([]byte(""))
-
defer func() {
if r := recover(); r == nil {
t.Errorf("UserID Generation should panic on empty key")
diff --git a/signature/dsa.go b/signature/dsa.go
index fc477a2759ef98ff871407d95db68533bf8181a4..e7f2aa8ef61dcebdfaeabe2aba21bf985b8d0e84 100644
--- a/signature/dsa.go
+++ b/signature/dsa.go
@@ -3,7 +3,7 @@ package signature
import (
"crypto/dsa"
jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/crypto/large"
"io"
)
@@ -39,15 +39,15 @@ const (
)
func GetDefaultDSAParams() *DSAParameters {
- bigP := cyclic.NewIntFromString(DSA_GROUP_P, 16)
- bigQ := cyclic.NewIntFromString(DSA_GROUP_Q, 16)
- bigG := cyclic.NewIntFromString(DSA_GROUP_G, 16)
+ bigP := large.NewIntFromString(DSA_GROUP_P, 16)
+ bigQ := large.NewIntFromString(DSA_GROUP_Q, 16)
+ bigG := large.NewIntFromString(DSA_GROUP_G, 16)
jww.WARN.Printf("Using hardcoded DSA Params, should be removed in the future!")
return CustomDSAParams(bigP, bigQ, bigG)
}
-func CustomDSAParams(P, Q, G *cyclic.Int) *DSAParameters {
- return &DSAParameters{dsa.Parameters{P: P.GetBigInt(), Q: Q.GetBigInt(), G: G.GetBigInt()}}
+func CustomDSAParams(P, Q, G large.Int) *DSAParameters {
+ return &DSAParameters{dsa.Parameters{P: P.BigInt(), Q: Q.BigInt(), G: G.BigInt()}}
}
func NewDSAParams(rng io.Reader, pSizes ParameterSizes) *DSAParameters {
@@ -81,16 +81,16 @@ func (p *DSAParameters) PrivateKeyGen(rng io.Reader) *DSAPrivateKey {
return &pk
}
-func (p *DSAParameters) GetG() *cyclic.Int {
- return cyclic.NewIntFromBigInt(p.params.G)
+func (p *DSAParameters) GetG() large.Int {
+ return large.NewIntFromBigInt(p.params.G)
}
-func (p *DSAParameters) GetP() *cyclic.Int {
- return cyclic.NewIntFromBigInt(p.params.P)
+func (p *DSAParameters) GetP() large.Int {
+ return large.NewIntFromBigInt(p.params.P)
}
-func (p *DSAParameters) GetQ() *cyclic.Int {
- return cyclic.NewIntFromBigInt(p.params.Q)
+func (p *DSAParameters) GetQ() large.Int {
+ return large.NewIntFromBigInt(p.params.Q)
}
func (k *DSAPublicKey) GetParams() *DSAParameters {
@@ -109,33 +109,37 @@ func (p *DSAPrivateKey) Sign(data []byte, rng io.Reader) (*DSASignature, error)
r, s, err := dsa.Sign(rng, &p.key, data)
- rCyclic := cyclic.NewIntFromBigInt(r)
- sCyclic := cyclic.NewIntFromBigInt(s)
+ rval := large.Int(nil)
+ sval := large.Int(nil)
- return &DSASignature{rCyclic, sCyclic}, err
+ if err == nil {
+ rval = large.NewIntFromBigInt(r)
+ sval = large.NewIntFromBigInt(s)
+ }
+ return &DSASignature{rval, sval}, err
}
-func (p *DSAPrivateKey) GetKey() *cyclic.Int {
- return cyclic.NewIntFromBigInt(p.key.X)
+func (p *DSAPrivateKey) GetKey() large.Int {
+ return large.NewIntFromBigInt(p.key.X)
}
-func (dsaKey *DSAPrivateKey) GetPublicKey() *cyclic.Int {
- return cyclic.NewIntFromBigInt(dsaKey.key.PublicKey.Y)
+func (dsaKey *DSAPrivateKey) GetPublicKey() large.Int {
+ return large.NewIntFromBigInt(dsaKey.key.PublicKey.Y)
}
-func (dsaKey *DSAPrivateKey) GetParams() (p, q, g *cyclic.Int) {
- p = cyclic.NewIntFromBigInt(dsaKey.key.P)
- q = cyclic.NewIntFromBigInt(dsaKey.key.Q)
- g = cyclic.NewIntFromBigInt(dsaKey.key.G)
+func (dsaKey *DSAPrivateKey) GetParams() (p, q, g large.Int) {
+ p = large.NewIntFromBigInt(dsaKey.key.P)
+ q = large.NewIntFromBigInt(dsaKey.key.Q)
+ g = large.NewIntFromBigInt(dsaKey.key.G)
return p, q, g
}
-func ReconstructPrivateKey(publicKey *DSAPublicKey, privateKey *cyclic.Int) *DSAPrivateKey {
+func ReconstructPrivateKey(publicKey *DSAPublicKey, privateKey large.Int) *DSAPrivateKey {
pk := &DSAPrivateKey{}
pk.key.PublicKey = publicKey.key
- pk.key.X = privateKey.GetBigInt()
+ pk.key.X = privateKey.BigInt()
return pk
}
@@ -144,25 +148,25 @@ type DSAPublicKey struct {
key dsa.PublicKey
}
-func ReconstructPublicKey(p *DSAParameters, key *cyclic.Int) *DSAPublicKey {
+func ReconstructPublicKey(p *DSAParameters, key large.Int) *DSAPublicKey {
pk := &DSAPublicKey{}
pk.key.Parameters = p.params
- pk.key.Y = key.GetBigInt()
+ pk.key.Y = key.BigInt()
return pk
}
func (p *DSAPublicKey) Verify(hash []byte, sig DSASignature) bool {
- return dsa.Verify(&p.key, hash, sig.R.GetBigInt(), sig.S.GetBigInt())
+ return dsa.Verify(&p.key, hash, sig.R.BigInt(), sig.S.BigInt())
}
-func (p *DSAPublicKey) GetKey() *cyclic.Int {
- return cyclic.NewIntFromBigInt(p.key.Y)
+func (p *DSAPublicKey) GetKey() large.Int {
+ return large.NewIntFromBigInt(p.key.Y)
}
type DSASignature struct {
- R *cyclic.Int
- S *cyclic.Int
+ R large.Int
+ S large.Int
}
// TODO: Add tests for Gob encode/decode and uncomment impl.
diff --git a/signature/dsa_test.go b/signature/dsa_test.go
index 0f08c7ae1f622726281b01e416d9b3f22ecde168..20f60651227a00ba12a4e093745d45f2928748dd 100644
--- a/signature/dsa_test.go
+++ b/signature/dsa_test.go
@@ -9,7 +9,7 @@ package signature
import (
cryptoRand "crypto/rand"
"errors"
- "gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/crypto/large"
"math/big"
"math/rand"
"testing"
@@ -21,9 +21,9 @@ func TestCustomDSAParams_Accessors(t *testing.T) {
var pExpected, qExpected, gExpected int64 = 1, 1, 1
- p := cyclic.NewInt(pExpected)
- q := cyclic.NewInt(qExpected)
- g := cyclic.NewInt(gExpected)
+ p := large.NewInt(pExpected)
+ q := large.NewInt(qExpected)
+ g := large.NewInt(gExpected)
dsaParams := CustomDSAParams(p, q, g)
@@ -43,9 +43,9 @@ func TestCustomDSAParams_Accessors(t *testing.T) {
pExpected, qExpected, gExpected = 1, 2, 3
- p = cyclic.NewInt(pExpected)
- q = cyclic.NewInt(qExpected)
- g = cyclic.NewInt(gExpected)
+ p = large.NewInt(pExpected)
+ q = large.NewInt(qExpected)
+ g = large.NewInt(gExpected)
dsaParams = CustomDSAParams(p, q, g)
@@ -65,9 +65,9 @@ func TestCustomDSAParams_Accessors(t *testing.T) {
pExpected, qExpected, gExpected = 123, 456, 789
- p = cyclic.NewInt(pExpected)
- q = cyclic.NewInt(qExpected)
- g = cyclic.NewInt(gExpected)
+ p = large.NewInt(pExpected)
+ q = large.NewInt(qExpected)
+ g = large.NewInt(gExpected)
dsaParams = CustomDSAParams(p, q, g)
@@ -207,7 +207,7 @@ func TestDSAPublicKeyGetters(t *testing.T) {
params := NewDSAParams(r, L1024N160)
- key := cyclic.NewInt(500)
+ key := large.NewInt(500)
pubKey := ReconstructPublicKey(params, key)
@@ -272,15 +272,15 @@ func TestPublicKeyGen_Consistent(t *testing.T) {
}
-// Test helper which converts a hex string into a cyclic int
-func fromHex(s string) *cyclic.Int {
+// Test helper which converts a hex string into a large int
+func fromHex(s string) large.Int {
result, ok := new(big.Int).SetString(s, 16)
if !ok {
panic(s)
}
- return cyclic.NewIntFromBigInt(result)
+ return large.NewIntFromBigInt(result)
}
// Sign and verify that has param, pub & priv key values ported from go sdk dsa impl. tests.
@@ -386,12 +386,12 @@ func testParameterGeneration(t *testing.T, sizes ParameterSizes, L, N int) {
one := new(big.Int)
one.SetInt64(1)
- pm1 := new(big.Int).Sub(params.GetP().GetBigInt(), one)
- quo, rem := new(big.Int).DivMod(pm1, params.GetQ().GetBigInt(), new(big.Int))
+ pm1 := new(big.Int).Sub(params.GetP().BigInt(), one)
+ quo, rem := new(big.Int).DivMod(pm1, params.GetQ().BigInt(), new(big.Int))
if rem.Sign() != 0 {
t.Errorf("%d: p-1 mod q != 0", int(sizes))
}
- x := new(big.Int).Exp(params.GetG().GetBigInt(), quo, params.GetP().GetBigInt())
+ x := new(big.Int).Exp(params.GetG().BigInt(), quo, params.GetP().BigInt())
if x.Cmp(one) == 0 {
t.Errorf("%d: invalid generator", int(sizes))
}