-
Notifications
You must be signed in to change notification settings - Fork 169
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Cross-platform compatibility #502
Closed
Closed
Changes from 17 commits
Commits
Show all changes
24 commits
Select commit
Hold shift + click to select a range
1fb8a2c
int64 to share
matteosz d6942c8
Migrate to int64 for every int field
matteosz f2b69d2
Add ecies benchmark
K1li4nL 7056881
Add bn256 benchmark
K1li4nL cc57969
Add proof becnhmark
K1li4nL 7f0190d
Add missing for loops
K1li4nL 17f2d00
Set fixed number of predicates for benchmark
K1li4nL cd73d10
Some refactoring
K1li4nL 1296138
Add test wrong shuffles on pair
K1li4nL 6d2858e
Add test wrong Shuffle Sequence
K1li4nL e6aa56c
Add negative test for shuffle/Biffle
K1li4nL 20358b2
Fix comment
K1li4nL 83e79eb
Reduce code duplication
K1li4nL f673a52
Switched to uint32 for idx and th
matteosz bc725ac
Merge branch 'master' into matteo-int-xplatform
matteosz dd5884a
Rebased with drandmerge fork
matteosz 75451a1
Added 32bit CI tests
matteosz 06708ff
Fixed faulty tests
matteosz 05cdaac
Merge conflicts in dkg_test
matteosz c01c053
Merge commit
matteosz 0dd6b32
Modified workflow
matteosz a3b0225
Moved x86 ci changes to separate PR
matteosz 81c8881
Merge branch 'drandmerge' into matteo-int-xplatform
matteosz da79359
Merge branch 'drandmerge' into matteo-int-xplatform
matteosz File filter
Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,262 @@ | ||
| package examples | ||
|
|
||
| import ( | ||
| "os" | ||
| "strconv" | ||
| "testing" | ||
|
|
||
| "github.com/stretchr/testify/require" | ||
| "go.dedis.ch/kyber/v3" | ||
| "go.dedis.ch/kyber/v3/group/edwards25519" | ||
| "go.dedis.ch/kyber/v3/share" | ||
| dkg "go.dedis.ch/kyber/v3/share/dkg/pedersen" | ||
| ) | ||
|
|
||
| var suite = edwards25519.NewBlakeSHA256Ed25519() | ||
|
|
||
| /* | ||
| This example illustrates how to use the dkg/pedersen API to generate a public | ||
| key and its corresponding private key that is shared among nodes. It shows the | ||
| different phases that each node must perform in order to construct the private | ||
| shares that will form the final private key. The example uses 3 nodes and shows | ||
| the "happy" path where each node does its job correctly. | ||
| */ | ||
| func Test_Example_DKG(t *testing.T) { | ||
|
|
||
| // DKG scales exponentially, the following command prints the duration [ns] | ||
| // of this test case with an increasing number of nodes. The resulting plot | ||
| // should illustrate an exponential growth. | ||
| // | ||
| // for (( i=1; i<30; i++ )); do | ||
| // start=`gdate +%s%N` | ||
| // NUM_NODES=$i go test -run Test_Example_DKG >/dev/null | ||
| // duration=$(( `gdate +%s%N` - start )) | ||
| // echo $duration | ||
| // done | ||
| // | ||
| var nStr = os.Getenv("NUM_NODES") | ||
| if nStr == "" { | ||
| // default number of node for this test | ||
| nStr = "7" | ||
| } | ||
| nUnsz, err := strconv.Atoi(nStr) | ||
| n := uint32(nUnsz) | ||
| require.NoError(t, err) | ||
|
|
||
| type node struct { | ||
| dkg *dkg.DistKeyGenerator | ||
| pubKey kyber.Point | ||
| privKey kyber.Scalar | ||
| deals []*dkg.Deal | ||
| resps []*dkg.Response | ||
| secretShare *share.PriShare | ||
| } | ||
|
|
||
| nodes := make([]*node, n) | ||
| pubKeys := make([]kyber.Point, n) | ||
|
|
||
| // 1. Init the nodes | ||
| for i := uint32(0); i < n; i++ { | ||
| privKey := suite.Scalar().Pick(suite.RandomStream()) | ||
| pubKey := suite.Point().Mul(privKey, nil) | ||
| pubKeys[i] = pubKey | ||
| nodes[i] = &node{ | ||
| pubKey: pubKey, | ||
| privKey: privKey, | ||
| deals: make([]*dkg.Deal, 0), | ||
| resps: make([]*dkg.Response, 0), | ||
| } | ||
| } | ||
|
|
||
| // 2. Create the DKGs on each node | ||
| for i, node := range nodes { | ||
| dkg, err := dkg.NewDistKeyGenerator(suite, nodes[i].privKey, pubKeys, n) | ||
| require.NoError(t, err) | ||
| node.dkg = dkg | ||
| } | ||
|
|
||
| // 3. Each node sends its Deals to the other nodes | ||
| for _, node := range nodes { | ||
| deals, err := node.dkg.Deals() | ||
| require.NoError(t, err) | ||
| for i, deal := range deals { | ||
| nodes[i].deals = append(nodes[i].deals, deal) | ||
| } | ||
| } | ||
|
|
||
| // 4. Process the Deals on each node and send the responses to the other | ||
| // nodes | ||
| for i, node := range nodes { | ||
| for _, deal := range node.deals { | ||
| resp, err := node.dkg.ProcessDeal(deal) | ||
| require.NoError(t, err) | ||
| for j, otherNode := range nodes { | ||
| if j == i { | ||
| continue | ||
| } | ||
| otherNode.resps = append(otherNode.resps, resp) | ||
| } | ||
| } | ||
| } | ||
|
|
||
| // 5. Process the responses on each node | ||
| for _, node := range nodes { | ||
| for _, resp := range node.resps { | ||
| _, err := node.dkg.ProcessResponse(resp) | ||
| require.NoError(t, err) | ||
| // err = node.dkg.ProcessJustification(justification) | ||
| // require.NoError(t, err) | ||
| } | ||
| } | ||
|
|
||
| // 6. Check and print the qualified shares | ||
| for _, node := range nodes { | ||
| require.True(t, node.dkg.Certified()) | ||
| require.Equal(t, n, uint32(len(node.dkg.QualifiedShares()))) | ||
| require.Equal(t, n, uint32(len(node.dkg.QUAL()))) | ||
| t.Log("qualified shares:", node.dkg.QualifiedShares()) | ||
| t.Log("QUAL", node.dkg.QUAL()) | ||
| } | ||
|
|
||
| // 7. Get the secret shares and public key | ||
| shares := make([]*share.PriShare, n) | ||
| var publicKey kyber.Point | ||
| for i, node := range nodes { | ||
| distrKey, err := node.dkg.DistKeyShare() | ||
| require.NoError(t, err) | ||
| shares[i] = distrKey.PriShare() | ||
| publicKey = distrKey.Public() | ||
| node.secretShare = distrKey.PriShare() | ||
| t.Log("new distributed public key:", publicKey) | ||
| } | ||
|
|
||
| // 8. Variant A - Encrypt a secret with the public key and decrypt it with | ||
| // the reconstructed shared secret key. Reconstructing the shared secret key | ||
| // in not something we should do as it gives the power to decrypt any | ||
| // further messages encrypted with the shared public key. For this we show | ||
| // in variant B how to make nodes send back partial decryptions instead of | ||
| // their shares. In variant C the nodes return partial decrpytions that are | ||
| // encrypted under a provided public key. | ||
| message := []byte("Hello world") | ||
| secretKey, err := share.RecoverSecret(suite, shares, n, n) | ||
| require.NoError(t, err) | ||
| K, C, remainder := ElGamalEncrypt(suite, publicKey, message) | ||
| require.Equal(t, 0, len(remainder)) | ||
| decryptedMessage, err := ElGamalDecrypt(suite, secretKey, K, C) | ||
| require.Equal(t, message, decryptedMessage) | ||
|
|
||
| // 8. Variant B - Each node provide only a partial decryption by sending its | ||
| // public share. We then reconstruct the public commitment with those public | ||
| // shares. | ||
| partials := make([]kyber.Point, n) | ||
| pubShares := make([]*share.PubShare, n) | ||
| for i, node := range nodes { | ||
| S := suite.Point().Mul(node.secretShare.V, K) | ||
| partials[i] = suite.Point().Sub(C, S) | ||
| pubShares[i] = &share.PubShare{ | ||
| I: uint32(i), V: partials[i], | ||
| } | ||
| } | ||
|
|
||
| // Reconstruct the public commitment, which contains the decrypted message | ||
| res, err := share.RecoverCommit(suite, pubShares, n, n) | ||
| require.NoError(t, err) | ||
| decryptedMessage, err = res.Data() | ||
| require.NoError(t, err) | ||
| require.Equal(t, message, decryptedMessage) | ||
|
|
||
| // 8 Variant C - Nodes return a partial decryption under the encryption from | ||
| // the client's provided public key. This is useful in case the decryption | ||
| // happens in public. In that case the decrypted message is never released | ||
| // in clear, but the message is revealed re-encrypted under the provided | ||
| // public key. | ||
| // | ||
| // Here is the crypto that happens in 3 phases: | ||
| // | ||
| // (1) Message encryption: | ||
| // | ||
| // r: random point | ||
| // A: dkg public key | ||
| // G: curve's generator | ||
| // M: message to encrypt | ||
| // (C, U): encrypted message | ||
| // | ||
| // C = rA + M | ||
| // U = rG | ||
| // | ||
| // (2) Node's partial decryption | ||
| // | ||
| // V: node's public re-encrypted share | ||
| // o: node's private share | ||
| // Q: client's public key (pG) | ||
| // | ||
| // V = oU + oQ | ||
| // | ||
| // (3) Message's decryption | ||
| // | ||
| // R: recovered commit (f(V1, V2, ...Vi)) using Lagrange interpolation | ||
| // p: client's private key | ||
| // M': decrypted message | ||
| // | ||
| // M' = C - (R - pA) | ||
|
|
||
| A := publicKey | ||
| r := suite.Scalar().Pick(suite.RandomStream()) | ||
| M := suite.Point().Embed(message, suite.RandomStream()) | ||
| C = suite.Point().Add( // rA + M | ||
| suite.Point().Mul(r, A), // rA | ||
| M, | ||
| ) | ||
| U := suite.Point().Mul(r, nil) // rG | ||
|
|
||
| p := suite.Scalar().Pick(suite.RandomStream()) | ||
| Q := suite.Point().Mul(p, nil) // pG | ||
|
|
||
| partials = make([]kyber.Point, n) | ||
| pubShares = make([]*share.PubShare, n) // V1, V2, ...Vi | ||
| for i, node := range nodes { | ||
| v := suite.Point().Add( // oU + oQ | ||
| suite.Point().Mul(node.secretShare.V, U), // oU | ||
| suite.Point().Mul(node.secretShare.V, Q), // oQ | ||
| ) | ||
| partials[i] = v | ||
| pubShares[i] = &share.PubShare{ | ||
| I: uint32(i), V: partials[i], | ||
| } | ||
| } | ||
|
|
||
| R, err := share.RecoverCommit(suite, pubShares, n, n) // R = f(V1, V2, ...Vi) | ||
| require.NoError(t, err) | ||
|
|
||
| decryptedPoint := suite.Point().Sub( // C - (R - pA) | ||
| C, | ||
| suite.Point().Sub( // R - pA | ||
| R, | ||
| suite.Point().Mul(p, A), // pA | ||
| ), | ||
| ) | ||
| decryptedMessage, err = decryptedPoint.Data() | ||
| require.NoError(t, err) | ||
| require.Equal(t, decryptedMessage, message) | ||
|
|
||
| // 9. The following shows a re-share of the dkg key, which will invalidates | ||
| // the current shares on each node and produce a new public key. After that | ||
| // steps 3, 4, 5 need to be done in order to get the new shares and public | ||
| // key. | ||
| for _, node := range nodes { | ||
| share, err := node.dkg.DistKeyShare() | ||
| require.NoError(t, err) | ||
| c := &dkg.Config{ | ||
| Suite: suite, | ||
| Longterm: node.privKey, | ||
| OldNodes: pubKeys, | ||
| NewNodes: pubKeys, | ||
| Share: share, | ||
| Threshold: n, | ||
| OldThreshold: n, | ||
| } | ||
| newDkg, err := dkg.NewDistKeyHandler(c) | ||
| require.NoError(t, err) | ||
| node.dkg = newDkg | ||
| } | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Maybe add a step that does a
uname -aand ago envjust to be able to double check that it works?There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
You can see that in the runner anyway, at the top...
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I don't think that would be the case for the Alpine x86 job, since it seems to run on the same worker, no?
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Ah, I didn't see that it only runs 3 out of the 4 entries in the matrix - according to the Standard Github Runners, the
ubuntu-latest-x86doesn't exist. So perhaps it's just ignored?If you look at the checks from this PR, only 3 are run. And I cannot see anything about two tests being run on the
ubuntu-latest.There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I don't think the new workflow would be executed until the changes haven't been merged
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Now I'm confused:
synchronizetype will launch the script every time you do agit push.github/workflows/test_on_pr.ymlanymore - did you remove the changes?I do think it's a good idea to add the 32-bit test to the workflow. And if I'm not mistaken, the workflow has actually been run. It's just that the
-x86target doesn't exist. But I didn't test it.There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
So, yes the synchronize make the CI to run for every git push, however the CI that is run is the one which is already on the master branch (or the drandmerge since it's the base branch now). Hence, I changed the workflow to execute separate jobs (thus avoiding the -x86 target issue) and the changes weren't detected either, so I moved the CI changes to a separate PR to merge before this one so we have the correct CI tests running.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
OK, as I have too many things going on and couldn't decide where to start, I did this:
https://github.com/ineiti/test_ubuntu_32bits/blob/main/.github/workflows/test.yaml
some notes:
shell: alpine.sh {0}, so I think you're still running it on 64-bits and not 32-bitsunamedoesn't show it's 32-bits, so I usedgetconf LONG_BIT- thanks to stackoverflowI hope that helps...
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Will update the CI with that
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Great, a good CI-pipeline is worth putting some effort in!