From 59e3e9019fad194458195bbac1d8cbbc890702cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=9E=D0=BB=D0=B5=D0=B3=20=D0=91=D0=BE=D1=80=D0=BE=D0=B4?=
 =?UTF-8?q?=D0=B8=D0=BD?= <onborodin@basistech.ru>
Date: Sat, 7 Mar 2026 09:15:21 +0200
Subject: [PATCH] updated digest.go: added function

---
 pkg/digest/digest.go | 95 ++++++++++++++++++++++++++++++++++----------
 1 file changed, 74 insertions(+), 21 deletions(-)

diff --git a/pkg/digest/digest.go b/pkg/digest/digest.go
index 686cf3c..f07e5a0 100644
--- a/pkg/digest/digest.go
+++ b/pkg/digest/digest.go
@@ -1,12 +1,12 @@
 package digest
 
 import (
+	"bytes"
 	"crypto/sha256"
 	"crypto/sha512"
-	"hash"
-
 	"encoding/hex"
 	"errors"
+	"hash"
 	"strings"
 )
 
@@ -37,16 +37,16 @@ func NewDigest(algorithm Algorithm, payload []byte) *Digest {
 	}
 	hasher.Write(payload)
 	sum = hasher.Sum(nil)
-	digest := &Digest{
+	digobj := &Digest{
 		algorithm: algorithm,
 		decoded:   sum,
 	}
-	return digest
+	return digobj
 }
 
 func ParseDigest(str string) (*Digest, error) {
 	var err error
-	digest := &Digest{}
+	digobj := &Digest{}
 
 	str = strings.ToLower(str)
 	str = strings.TrimPrefix(str, "sha256:")
@@ -55,22 +55,22 @@ func ParseDigest(str string) (*Digest, error) {
 
 	decoded, err := hex.DecodeString(str)
 	if err != nil {
-		err := errors.New("Can't decode digest")
-		return digest, err
+		err := errors.New("Can't decode digobj")
+		return digobj, err
 	}
-	digest.decoded = decoded
+	digobj.decoded = decoded
 	switch len(decoded) {
 	case 32:
-		digest.algorithm = SHA256
+		digobj.algorithm = SHA256
 	case 48:
-		digest.algorithm = SHA384
+		digobj.algorithm = SHA384
 	case 64:
-		digest.algorithm = SHA512
+		digobj.algorithm = SHA512
 	default:
 		err = errors.New("Unknown digest type")
-		return digest, err
+		return digobj, err
 	}
-	return digest, err
+	return digobj, err
 }
 
 func (dig *Digest) Encoded() string {
@@ -108,14 +108,14 @@ func (dig *Digest) String() string {
 	return prefix + ":" + hexx
 }
 
-func xxxDigestType(digest string) Algorithm {
+func DetectDigestType(digobj string) Algorithm {
 	var err error
 	var algorithm Algorithm
-	digest = strings.ToLower(digest)
-	digest = strings.TrimPrefix(digest, "sha256:")
-	digest = strings.TrimPrefix(digest, "sha384:")
-	digest = strings.TrimPrefix(digest, "sha512:")
-	decoded, err := hex.DecodeString(digest)
+	digobj = strings.ToLower(digobj)
+	digobj = strings.TrimPrefix(digobj, "sha256:")
+	digobj = strings.TrimPrefix(digobj, "sha384:")
+	digobj = strings.TrimPrefix(digobj, "sha512:")
+	decoded, err := hex.DecodeString(digobj)
 	if err != nil {
 		return Undefined
 	}
@@ -132,16 +132,69 @@ func xxxDigestType(digest string) Algorithm {
 	return algorithm
 }
 
-func xxxSHA256Digest(src []byte) string {
+func MakeSHA256Digest(src []byte) string {
 	hasher := sha256.New()
 	hasher.Write(src)
 	sum := hasher.Sum(nil)
 	return "sha256:" + hex.EncodeToString(sum)
 }
 
-func xxxSHA512Digest(src []byte) string {
+func MakeSHA384Digest(src []byte) string {
+	hasher := sha512.New384()
+	hasher.Write(src)
+	sum := hasher.Sum(nil)
+	return "sha256:" + hex.EncodeToString(sum)
+}
+
+func MakeSHA512Digest(src []byte) string {
 	hasher := sha512.New()
 	hasher.Write(src)
 	sum := hasher.Sum(nil)
 	return "sha512:" + hex.EncodeToString(sum)
 }
+
+func (dig Digest) MarshalJSON() ([]byte, error) {
+	writer := bytes.NewBuffer(nil)
+	switch dig.algorithm {
+	case SHA256:
+		writer.WriteString("sha256")
+	case SHA384:
+		writer.WriteString("sha384")
+	case SHA512:
+		writer.WriteString("sha512")
+	}
+	writer.WriteString(":")
+	writer.WriteString(hex.EncodeToString(dig.decoded))
+	return writer.Bytes(), nil
+}
+
+func (dig *Digest) UnmarshalJSON(data []byte) error {
+	var err error
+	digobj := &Digest{}
+
+	str := strings.ToLower(string(data))
+	str = strings.TrimPrefix(str, "sha256:")
+	str = strings.TrimPrefix(str, "sha384:")
+	str = strings.TrimPrefix(str, "sha512:")
+
+	decoded, err := hex.DecodeString(str)
+	if err != nil {
+		err := errors.New("Can't decode digest")
+		return digobj, err
+	}
+	digobj.decoded = decoded
+	switch len(decoded) {
+	case 32:
+		digobj.algorithm = SHA256
+	case 48:
+		digobj.algorithm = SHA384
+	case 64:
+		digobj.algorithm = SHA512
+	default:
+		err = errors.New("Unknown digest type")
+		return digobj, err
+	}
+	*dig = digobj
+	return err
+
+}