Refactor public API to be more usable

Author: lafriks

.github/workflows/go.yml

@@ -0,0 +1,44 @@
+name: Go
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+
+    - name: Set up Go 1.x
+      uses: actions/setup-go@v2
+      with:
+        go-version: ^1.14
+
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v2
+
+    - name: Install dependencies
+      run: |
+        go version
+        go get -u golang.org/x/lint/golint
+
+    - name: Run vet & lint
+      run: |
+        go vet ./...
+        golint ./...
+
+    - name: Test
+      run: go test -v -covermode=count -coverprofile=coverage.out ./...
+
+    - name: Convert coverage
+      uses: jandelgado/gcov2lcov-action@v1.0.5
+
+    - name: Coveralls
+      uses: coverallsapp/github-action@v1.1.2
+      with:
+        github-token: ${{ secrets.github_token }}
+        path-to-lcov: coverage.lcov

README.md

@@ -1,5 +1,8 @@
 # Shamir's Secret Sharing
 
+[![Go Reference](https://pkg.go.dev/badge/github.com/lafriks/go-shamir.svg)](https://pkg.go.dev/github.com/lafriks/go-shamir)
+[![Coverage Status](https://coveralls.io/repos/github/lafriks/go-shamir/badge.svg?branch=master)](https://coveralls.io/github/lafriks/go-shamir?branch=master)
+
 Based on [github.com/codahale/sss](https://github.com/codahale/sss)
 
 A pure Go implementation of [Shamir's Secret Sharing algorithm](http://en.wikipedia.org/wiki/Shamir's_Secret_Sharing)
@@ -25,13 +28,13 @@ func main() {
     secret := []byte("example")
 
     // Split secret to 5 shares and require 3 shares to reconstruct secret
-    shares, err := Split(5, 3, secret)
+    shares, err := shamir.Split(secret, 5, 3)
     if err != nil {
         panic(err)
     }
 
     // Reconstruct secret from shares
-    reconstructed, err := Combine([][]byte{shares[0], shares[2], shares[4]})
+    reconstructed, err := shamir.Combine(shares[0], shares[2], shares[4])
     if err != nil {
         panic(err)
     }

shamir.go

@@ -57,7 +57,7 @@ var (
 
 // Split the given secret into N shares of which K are required to recover the
 // secret. Returns an array of shares.
-func Split(n, k int, secret []byte) ([][]byte, error) {
+func Split(secret []byte, n, k int) ([][]byte, error) {
 	if k <= 1 || k > 255 {
 		return nil, ErrInvalidThreshold
 	}
@@ -95,7 +95,7 @@ func Split(n, k int, secret []byte) ([][]byte, error) {
 }
 
 // Combine the given shares into the original secret.
-func Combine(shares [][]byte) ([]byte, error) {
+func Combine(shares ...[]byte) ([]byte, error) {
 	if len(shares) < 2 || len(shares[0]) < 2 {
 		return nil, ErrInvalidShares
 	}

shamir_test.go

@@ -9,7 +9,7 @@ import (
 func TestSplit_valid(t *testing.T) {
 	secret := []byte("example")
 
-	shares, err := Split(5, 3, secret)
+	shares, err := Split(secret, 5, 3)
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
@@ -28,31 +28,31 @@ func TestSplit_valid(t *testing.T) {
 func TestSplit_invalid(t *testing.T) {
 	secret := []byte("example")
 
-	if _, err := Split(5, 0, secret); !errors.Is(err, ErrInvalidThreshold) {
+	if _, err := Split(secret, 5, 0); !errors.Is(err, ErrInvalidThreshold) {
 		t.Fatal("Expected ErrInvalidCount")
 	}
 
-	if _, err := Split(0, 3, secret); !errors.Is(err, ErrInvalidCount) {
+	if _, err := Split(secret, 0, 3); !errors.Is(err, ErrInvalidCount) {
 		t.Fatal("Expected ErrInvalidCount")
 	}
 
-	if _, err := Split(400, 300, secret); !errors.Is(err, ErrInvalidThreshold) {
+	if _, err := Split(secret, 400, 300); !errors.Is(err, ErrInvalidThreshold) {
 		t.Fatal("Expected ErrInvalidCount")
 	}
 
-	if _, err := Split(300, 3, secret); !errors.Is(err, ErrInvalidCount) {
+	if _, err := Split(secret, 300, 3); !errors.Is(err, ErrInvalidCount) {
 		t.Fatal("Expected ErrInvalidCount")
 	}
 
-	if _, err := Split(5, 3, nil); !errors.Is(err, ErrEmptySecret) {
+	if _, err := Split(nil, 5, 3); !errors.Is(err, ErrEmptySecret) {
 		t.Fatal("Expected ErrEmptySecret")
 	}
 }
 
 func TestCombine_valid(t *testing.T) {
 	secret := []byte("example")
 
-	shares, err := Split(5, 3, secret)
+	shares, err := Split(secret, 5, 3)
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
@@ -66,7 +66,7 @@ func TestCombine_valid(t *testing.T) {
 				if k == i || k == j {
 					continue
 				}
-				reconstructed, err := Combine([][]byte{shares[i], shares[j], shares[k]})
+				reconstructed, err := Combine(shares[i], shares[j], shares[k])
 				if err != nil {
 					t.Fatalf("Unexpected error: %v", err)
 				}
@@ -84,15 +84,15 @@ func TestCombine_invalid(t *testing.T) {
 		t.Fatal("Expected ErrInvalidShares")
 	}
 
-	if _, err := Combine([][]byte{[]byte("exam"),[]byte("ple")}); err == nil {
+	if _, err := Combine([]byte("exam"), []byte("ple")); err == nil {
 		t.Fatal("Expected ErrInvalidShares")
 	}
 
-	if _, err := Combine([][]byte{[]byte("a"),[]byte("b")}); err == nil {
+	if _, err := Combine([]byte("a"), []byte("b")); err == nil {
 		t.Fatal("Expected ErrInvalidShares")
 	}
 
-	if _, err := Combine([][]byte{[]byte("aa"),[]byte("aa")}); err == nil {
+	if _, err := Combine([]byte("aa"), []byte("aa")); err == nil {
 		t.Fatal("Expected ErrInvalidShares")
 	}
-}
+}