feat: Issue 4

errors.go

@@ -28,6 +28,14 @@ var (
 	// The proof is issued too far into the future.
 	ErrFuture = errors.New("proof is issued too far into the future")
 
+	// The hash function is not available
+	ErrHashFnNotAvailable = errors.New("provided hash function is not available, please check binaries and linker")
+
+	// When using hash util func, errors 
+	// if more than one hash is provided in variadic args
+	ErrTooManyArgs = errors.New("too many arguments for function")
+
+
 	// The proof claims are not of correct type
 	ErrIncorrectClaimsType = errors.New("incorrect claims type")
 

utils.go

@@ -0,0 +1,56 @@
+package dpop
+
+import (
+	"crypto"
+	"encoding/hex"
+)
+
+// type MockHash struct {}
+
+// func NewMockHash() hash.Hash {
+// 	return &MockHash{}
+// }
+
+// func (m *MockHash) Write(p []byte) (n int, err error) {
+// 	return 0, nil
+// }
+
+// func (m *MockHash) Sum(b []byte) []byte {
+// 	return nil
+// }
+
+// func (m *MockHash) Reset() {}
+
+// func (m *MockHash) Size() int {
+// 	return 0
+// }
+
+// func (m *MockHash) BlockSize() int {
+// 	return 0
+// }
+
+// func (m *MockHash) Available() bool {
+// 	return false
+// }
+
+func HashEquals(inString string, encryptedString string, args ...crypto.Hash) (bool, error) {
+	var hashFn crypto.Hash
+	if len(args) > 1 {
+		return false, ErrTooManyArgs
+	} else if len(args) < 1 {
+		hashFn = crypto.SHA256
+	} else {
+		hashFn = args[0]
+	}
+	if !hashFn.Available() {
+		return false, ErrHashFnNotAvailable
+	}
+	hashFnInst := hashFn.HashFunc().New()
+	// helped me here https://forum.golangbridge.org/t/help-with-sha256-code-solved/8210/4
+	firstBytes, _ := hex.DecodeString(inString)
+	hashFnInst.Write(firstBytes)
+
+	res := hashFnInst.Sum(nil)
+	out := hex.EncodeToString(res)
+	return (encryptedString == out), nil
+}

utils_test.go

@@ -0,0 +1,73 @@
+package dpop_test
+
+import (
+	"crypto"
+	"testing"
+
+	"github.com/AxisCommunications/go-dpop"
+)
+
+
+const (
+	// Arrange
+	inString = "testString"
+	encryptedString = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+)
+
+func TestHashEq_TooManyArgs(t *testing.T) {
+
+	// Act
+	_, err := dpop.HashEquals(inString, encryptedString, crypto.Hash(crypto.SHA224), crypto.Hash(crypto.SHA3_384))
+
+	// Assert
+	if err != dpop.ErrTooManyArgs {
+		t.Errorf("wanted %e, got %e", dpop.ErrTooManyArgs, err)
+	}
+}
+
+func TestHashEq_NoArgs(t *testing.T) {
+	// Act
+	got, _ := dpop.HashEquals(inString, encryptedString)
+
+	// Assert
+	if got != true {
+		t.Errorf("wanted %t, got %t", true, got)
+	}
+}
+
+func TestHashEq_CustomCryptoArg(t *testing.T) {
+	// Arrange
+	outString := `38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b`
+	// Act
+	got, _ := dpop.HashEquals(inString, outString, crypto.SHA384)
+
+	// Assert
+	if got != true {
+		t.Errorf("wanted %t, got %t", true, got)
+	}
+}
+
+func TestHashEq_IncorrectEncryptedString(t *testing.T) {
+	// Arrange
+	outString := "this is definitely wrong : )"
+
+	// Act
+	got, _ := dpop.HashEquals(inString, outString)
+
+	// Assert
+	if got != false {
+		t.Errorf("wanted %t, got %t", false, got)
+	}
+}
+
+// func TestHashEq_AlgNotAvailable(t *testing.T) {
+
+// 	crypto.RegisterHash(99, dpop.NewMockHash)
+// 	// Act
+// 	_, err := dpop.HashEquals(inString, encryptedString, 99)
+
+// 	if err != dpop.ErrHashFnNotAvailable {
+// 		t.Errorf("wanted %e, got %e", dpop.ErrHashFnNotAvailable, err)
+// 	}
+// }
+