feat: add HpcrContractSignedEncrypted() to encrypt and sign contract

common/encrypt/encrypt_test.go

@@ -72,6 +72,7 @@ func TestGeneratePublicKey(t *testing.T) {
 	}
 
 	assert.Equal(t, result, string(publicKey))
+	assert.NotEmpty(t, err)
 }
 
 // Testcase to check if RandomPasswordGenerator() is able to generate random password

contract/contract.go

@@ -5,6 +5,7 @@ import (
 
 	enc "github.com/Sashwat-K/lib-hpcr/common/encrypt"
 	gen "github.com/Sashwat-K/lib-hpcr/common/general"
+	"gopkg.in/yaml.v3"
 )
 
 // HpcrText - function to generate base64 data and checksum from string
@@ -58,6 +59,59 @@ func HpcrTgz(folderPath string) (string, error) {
 	return tgzBase64, nil
 }
 
+// HpcrContractSignedEncrypted - function to generate Signed and Encrypted contract
+func HpcrContractSignedEncrypted(contract, privateKey, encryptionCertificate string) (string, error) {
+	var contractMap map[string]interface{}
+
+	if contract == "" || privateKey == "" {
+		return "", fmt.Errorf("either contract or private key not parsed")
+	}
+
+	encryptCertificate := gen.FetchEncryptionCertificate(encryptionCertificate)
+
+	err := yaml.Unmarshal([]byte(contract), &contractMap)
+	if err != nil {
+		return "", err
+	}
+
+	workloadData, err := gen.MapToYaml(contractMap["workload"].(map[string]interface{}))
+	if err != nil {
+		return "", err
+	}
+
+	encryptedWorkload, _, err := Encrypter(workloadData, encryptCertificate)
+	if err != nil {
+		return "", err
+	}
+
+	publicKey, err := enc.GeneratePublicKey(privateKey)
+	if err != nil {
+		return "", err
+	}
+
+	updatedEnv, err := gen.KeyValueInjector(contractMap["env"].(map[string]interface{}), "signingKey", gen.EncodeToBase64(publicKey))
+	if err != nil {
+		return "", err
+	}
+
+	encryptedEnv, _, err := Encrypter(updatedEnv, encryptCertificate)
+	if err != nil {
+		return "", err
+	}
+
+	workloadEnvSignature, err := enc.SignContract(encryptedWorkload, encryptedEnv, privateKey)
+	if err != nil {
+		return "", err
+	}
+
+	finalContract, err := enc.GenFinalSignedContract(encryptedWorkload, encryptedEnv, workloadEnvSignature)
+	if err != nil {
+		return "", err
+	}
+
+	return finalContract, nil
+}
+
 // Encrypter - function to generate encrypted hyper protect data from plain string
 func Encrypter(stringText, encryptionCertificate string) (string, string, error) {
 	encCert := gen.FetchEncryptionCertificate(encryptionCertificate)

contract/contract_test.go

@@ -2,9 +2,14 @@ package contract
 
 import (
 	"fmt"
+	"io"
+	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"gopkg.in/yaml.v3"
+
+	gen "github.com/Sashwat-K/lib-hpcr/common/general"
 )
 
 const (
@@ -21,6 +26,9 @@ const (
 	sampleChecksumJson = "f932f8ad556280f232f4b42d55b24ce7d2e909d3195ef60d49e92d49b735de2b"
 
 	sampleComposeFolderPath = "../samples/tgz"
+	simpleContractPath      = "../samples/simple_contract.yaml"
+
+	samplePrivateKeyPath = "../samples/encrypt/private.pem"
 )
 
 // Testcase to check if TestHpcrText() is able to encode text and generate SHA256
@@ -78,6 +86,51 @@ func TestHpcrTgz(t *testing.T) {
 	assert.NoError(t, err)
 }
 
+// Testcase to check if HpcrContractSignedEncrypted() is able to generate
+func TestHpcrContractSignedEncrypted(t *testing.T) {
+	var contractMap map[string]interface{}
+
+	file, err := os.Open(simpleContractPath)
+	if err != nil {
+		fmt.Println(err)
+	}
+	defer file.Close()
+
+	contract, err := io.ReadAll(file)
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	err = yaml.Unmarshal([]byte(contract), &contractMap)
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	privateKeyFile, err := os.Open(samplePrivateKeyPath)
+	if err != nil {
+		fmt.Println(err)
+	}
+	defer privateKeyFile.Close()
+
+	privateKey, err := io.ReadAll(privateKeyFile)
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	contractStr, err := gen.MapToYaml(contractMap)
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	result, err := HpcrContractSignedEncrypted(contractStr, string(privateKey), "")
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	assert.NotEmpty(t, result)
+	assert.NoError(t, err)
+}
+
 // Testcase to check if Encrypter() is able to encrypt and generate SHA256 from string
 func TestEncrypter(t *testing.T) {
 	result, sha256, err := Encrypter(sampleStringJson, "")