use package maps and package slices to simplify alg string parsing

Cyphrme · May 8, 2023 · 04e5df9 · 04e5df9
1 parent 01c154e
commit 04e5df9
Show file tree

Hide file tree

Showing 2 changed files with 36 additions and 141 deletions.
diff --git a/alg.go b/alg.go
@@ -9,6 +9,8 @@ import (
 	"strings"
 
 	"golang.org/x/crypto/sha3"
+	"golang.org/x/exp/maps"   // https://github.com/golang/go/issues/57436
+	"golang.org/x/exp/slices" // https://github.com/golang/go/issues/57433
 )
 
 type (
@@ -101,31 +103,33 @@ const (
 	SHAKE256       HshAlg = "SHAKE256"
 )
 
-// Algs is initialized in the init function to include all algs, including
-// "UnknownAlg", SigAlg, EncAlg, and HshAlg.
-var Algs = []Alg{
-	UnknownAlg,
-	Alg(UnknownSigAlg),
-	Alg(ES224),
-	Alg(ES256),
-	Alg(ES384),
-	Alg(ES512),
-	Alg(Ed25519),
-	Alg(Ed25519ph),
-	Alg(Ed448),
-	Alg(UnknownEncAlg),
-	Alg(UnknownHashAlg),
-	Alg(SHA224),
-	Alg(SHA256),
-	Alg(SHA384),
-	Alg(SHA512),
-	Alg(SHA3224),
-	Alg(SHA3256),
-	Alg(SHA3384),
-	Alg(SHA3512),
-	Alg(SHAKE128),
-	Alg(SHAKE256),
-}
+// Algs includes all algs, including
+// unknown algs, SigAlg, EncAlg, and HshAlg.
+var Algs = map[string]Alg{
+	string(UnknownAlg):     Alg(UnknownAlg),
+	string(UnknownSigAlg):  Alg(UnknownSigAlg),
+	string(ES224):          Alg(ES224),
+	string(ES256):          Alg(ES256),
+	string(ES384):          Alg(ES384),
+	string(ES512):          Alg(ES512),
+	string(Ed25519):        Alg(Ed25519),
+	string(Ed25519ph):      Alg(Ed25519ph),
+	string(Ed448):          Alg(Ed448),
+	string(UnknownEncAlg):  Alg(UnknownEncAlg),
+	string(UnknownHashAlg): Alg(UnknownHashAlg),
+	string(SHA224):         Alg(SHA224),
+	string(SHA256):         Alg(SHA256),
+	string(SHA384):         Alg(SHA384),
+	string(SHA512):         Alg(SHA512),
+	string(SHA3224):        Alg(SHA3224),
+	string(SHA3256):        Alg(SHA3256),
+	string(SHA3384):        Alg(SHA3384),
+	string(SHA3512):        Alg(SHA3512),
+	string(SHAKE128):       Alg(SHAKE128),
+	string(SHAKE256):       Alg(SHAKE256),
+}
+
+var algs []string = maps.Keys(Algs)
 
 var SigAlgs = []SigAlg{
 	UnknownSigAlg,
@@ -169,51 +173,11 @@ func Parse(s string) Alg {
 }
 
 func (a *Alg) Parse(s string) {
-	switch strings.Trim(s, `"`) {
-	default:
-		*a = UnknownAlg
-	case string(UnknownAlg):
+	s = strings.Trim(s, `"`)
+	if slices.Contains(algs, s) {
+		*a = Algs[s]
+	} else {
 		*a = UnknownAlg
-	case string(UnknownSigAlg):
-		*a = Alg(UnknownSigAlg)
-	case string(ES224):
-		*a = Alg(ES224)
-	case string(ES256):
-		*a = Alg(ES256)
-	case string(ES384):
-		*a = Alg(ES384)
-	case string(ES512):
-		*a = Alg(ES512)
-	case string(Ed25519):
-		*a = Alg(Ed25519)
-	case string(Ed25519ph):
-		*a = Alg(Ed25519ph)
-	case string(Ed448):
-		*a = Alg(Ed448)
-	case string(UnknownEncAlg):
-		*a = Alg(UnknownEncAlg)
-	case string(UnknownHashAlg):
-		*a = Alg(UnknownHashAlg)
-	case string(SHA224):
-		*a = Alg(SHA224)
-	case string(SHA256):
-		*a = Alg(SHA256)
-	case string(SHA384):
-		*a = Alg(SHA384)
-	case string(SHA512):
-		*a = Alg(SHA512)
-	case string(SHA3224):
-		*a = Alg(SHA3224)
-	case string(SHA3256):
-		*a = Alg(SHA3256)
-	case string(SHA3384):
-		*a = Alg(SHA3384)
-	case string(SHA3512):
-		*a = Alg(SHA3512)
-	case string(SHAKE128):
-		*a = Alg(SHAKE128)
-	case string(SHAKE256):
-		*a = Alg(SHAKE256)
 	}
 }
 
@@ -332,24 +296,10 @@ const (
 )
 
 func (se SEAlg) SigAlg() SigAlg {
-	switch SigAlg(se) {
-	default:
-		return UnknownSigAlg
-	case ES224:
-		return ES224
-	case ES256:
-		return ES256
-	case ES384:
-		return ES384
-	case ES512:
-		return ES512
-	case Ed25519:
-		return Ed25519
-	case Ed25519ph:
-		return Ed25519ph
-	case Ed448:
-		return Ed448
+	if slices.Contains(SigAlgs, SigAlg(se)) {
+		return SigAlg(se)
 	}
+	return UnknownSigAlg
 }
 
 func (se *SEAlg) Parse(s string) {

diff --git a/alg_test.go b/alg_test.go
@@ -2,30 +2,8 @@ package coze
 
 import (
 	"fmt"
-	"strconv"
-	"testing"
-
-	"golang.org/x/exp/slices"
 )
 
-func ExampleAlgs_print() {
-	fmt.Println(Algs)
-
-	// Output:
-	// [UnknownAlg UnknownSigAlg ES224 ES256 ES384 ES512 Ed25519 Ed25519ph Ed448 UnknownEncAlg UnknownHashAlg SHA-224 SHA-256 SHA-384 SHA-512 SHA3-224 SHA3-256 SHA3-384 SHA3-512 SHAKE128 SHAKE256]
-}
-
-// Tests to make sure the alg enums are in order according to Parse.
-func TestParse(t *testing.T) {
-	algs := []Alg{}
-	for _, a := range Algs {
-		algs = append(algs, Parse(string(a)))
-	}
-	if !slices.Equal(Algs, algs) {
-		t.Fatal("slices not equal. ")
-	}
-}
-
 func ExampleAlg_jsonMarshal() {
 	type algStruct struct {
 		A Alg `json:"alg"`
@@ -213,36 +191,3 @@ func ExampleAlg_Params() {
 	// {"Name":"SHAKE128","Genus":"SHA3","Family":"SHA","Use":"hsh","Hash":"SHAKE128","HashSize":32,"HashSizeB64":43}
 	// {"Name":"SHAKE256","Genus":"SHA3","Family":"SHA","Use":"hsh","Hash":"SHAKE256","HashSize":64,"HashSizeB64":86}
 }
-
-func Example_curveOrder() {
-	algs := []SigAlg{
-		ES224,
-		ES256,
-		ES384,
-		ES512,
-	}
-
-	for _, a := range algs {
-		hexSize := Alg(a).Params().XSize
-		fmt.Printf("%0"+strconv.Itoa(hexSize)+"X\n", curveOrders[a])
-	}
-	fmt.Println()
-	for _, a := range algs {
-
-		hexSize := Alg(a).Params().XSize
-		fmt.Printf("%0"+strconv.Itoa(hexSize)+"X\n", curveHalfOrders[a])
-	}
-
-	// Output:
-	//
-	// FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D
-	// FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551
-	// FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973
-	// 01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409
-	//
-	// 7FFFFFFFFFFFFFFFFFFFFFFFFFFF8B51705C781F09EE94A2AE2E151E
-	// 7FFFFFFF800000007FFFFFFFFFFFFFFFDE737D56D38BCF4279DCE5617E3192A8
-	// 7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE3B1A6C0FA1B96EFAC0D06D9245853BD76760CB5666294B9
-	// 00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD28C343C1DF97CB35BFE600A47B84D2E81DDAE4DC44CE23D75DB7DB8F489C3204
-
-}