github.com/jasoet/gopki@v1.15.0/compatibility/helpers.go (about)

     1  package compatibility
     2  
     3  import (
     4  	"crypto/ecdsa"
     5  	"crypto/ed25519"
     6  	"crypto/rsa"
     7  	"crypto/sha256"
     8  	"crypto/x509"
     9  	"encoding/pem"
    10  	"fmt"
    11  	"os"
    12  	"os/exec"
    13  	"path/filepath"
    14  	"strings"
    15  	"testing"
    16  )
    17  
    18  // TestKeyPair represents a generated key pair for testing
    19  type TestKeyPair struct {
    20  	Algorithm  string
    21  	KeySize    int
    22  	CurveName  string
    23  	PrivateKey interface{}
    24  	PublicKey  interface{}
    25  	PrivatePEM []byte
    26  	PublicPEM  []byte
    27  	PrivateDER []byte
    28  	PublicDER  []byte
    29  	TempDir    string
    30  }
    31  
    32  // Cleanup removes temporary files created during testing
    33  func (tkp *TestKeyPair) Cleanup() {
    34  	if tkp.TempDir != "" {
    35  		os.RemoveAll(tkp.TempDir)
    36  	}
    37  }
    38  
    39  // OpenSSLHelper provides utilities for OpenSSL command execution
    40  type OpenSSLHelper struct {
    41  	t       *testing.T
    42  	tempDir string
    43  }
    44  
    45  // NewOpenSSLHelper creates a new OpenSSL helper instance
    46  func NewOpenSSLHelper(t *testing.T) *OpenSSLHelper {
    47  	tempDir, err := os.MkdirTemp("", "gopki_openssl_test_*")
    48  	if err != nil {
    49  		t.Fatalf("Failed to create temp directory: %v", err)
    50  	}
    51  	return &OpenSSLHelper{
    52  		t:       t,
    53  		tempDir: tempDir,
    54  	}
    55  }
    56  
    57  // Cleanup removes temporary files
    58  func (h *OpenSSLHelper) Cleanup() {
    59  	os.RemoveAll(h.tempDir)
    60  }
    61  
    62  // TempFile creates a temporary file with the given content
    63  func (h *OpenSSLHelper) TempFile(name string, content []byte) string {
    64  	filepath := filepath.Join(h.tempDir, name)
    65  	err := os.WriteFile(filepath, content, 0600)
    66  	if err != nil {
    67  		h.t.Fatalf("Failed to write temp file %s: %v", filepath, err)
    68  	}
    69  	return filepath
    70  }
    71  
    72  // RunOpenSSL executes an OpenSSL command and returns the output
    73  func (h *OpenSSLHelper) RunOpenSSL(args ...string) ([]byte, error) {
    74  	cmd := exec.Command("openssl", args...)
    75  
    76  	// Log the command being executed
    77  	h.t.Logf("    → Executing: openssl %s", strings.Join(args, " "))
    78  
    79  	output, err := cmd.CombinedOutput()
    80  	if err != nil {
    81  		h.t.Logf("    ❌ Command failed: %v", err)
    82  		if len(output) > 0 {
    83  			h.t.Logf("    ❌ Output: %s", string(output))
    84  		}
    85  		return output, fmt.Errorf("openssl command failed: %v, output: %s", err, string(output))
    86  	}
    87  
    88  	// Log successful execution
    89  	if len(output) > 0 && len(output) < 200 {
    90  		h.t.Logf("    ✓ Success: %s", strings.TrimSpace(string(output)))
    91  	} else if len(output) > 0 {
    92  		h.t.Logf("    ✓ Success: generated %d bytes of output", len(output))
    93  	} else {
    94  		h.t.Logf("    ✓ Success: command completed")
    95  	}
    96  
    97  	return output, nil
    98  }
    99  
   100  // GenerateRSAWithOpenSSL generates an RSA key pair using OpenSSL
   101  func (h *OpenSSLHelper) GenerateRSAWithOpenSSL(keySize int) (privateKeyPEM, publicKeyPEM []byte, err error) {
   102  	h.t.Logf("    → Generating RSA-%d key pair with OpenSSL...", keySize)
   103  
   104  	// Generate private key
   105  	privKeyFile := filepath.Join(h.tempDir, "rsa_private.pem")
   106  	pubKeyFile := filepath.Join(h.tempDir, "rsa_public.pem")
   107  
   108  	// Generate private key
   109  	_, err = h.RunOpenSSL("genpkey", "-algorithm", "RSA",
   110  		"-out", privKeyFile, "-pkeyopt", fmt.Sprintf("rsa_keygen_bits:%d", keySize))
   111  	if err != nil {
   112  		return nil, nil, fmt.Errorf("failed to generate RSA private key: %v", err)
   113  	}
   114  
   115  	// Extract public key
   116  	_, err = h.RunOpenSSL("pkey", "-in", privKeyFile, "-pubout", "-out", pubKeyFile)
   117  	if err != nil {
   118  		return nil, nil, fmt.Errorf("failed to extract RSA public key: %v", err)
   119  	}
   120  
   121  	// Read generated files
   122  	privateKeyPEM, err = os.ReadFile(privKeyFile)
   123  	if err != nil {
   124  		return nil, nil, fmt.Errorf("failed to read private key: %v", err)
   125  	}
   126  
   127  	publicKeyPEM, err = os.ReadFile(pubKeyFile)
   128  	if err != nil {
   129  		return nil, nil, fmt.Errorf("failed to read public key: %v", err)
   130  	}
   131  
   132  	return privateKeyPEM, publicKeyPEM, nil
   133  }
   134  
   135  // GenerateECDSAWithOpenSSL generates an ECDSA key pair using OpenSSL
   136  func (h *OpenSSLHelper) GenerateECDSAWithOpenSSL(curveName string) (privateKeyPEM, publicKeyPEM []byte, err error) {
   137  	privKeyFile := filepath.Join(h.tempDir, "ecdsa_private.pem")
   138  	pubKeyFile := filepath.Join(h.tempDir, "ecdsa_public.pem")
   139  
   140  	// Generate private key
   141  	_, err = h.RunOpenSSL("genpkey", "-algorithm", "EC",
   142  		"-out", privKeyFile, "-pkeyopt", "ec_paramgen_curve:"+curveName)
   143  	if err != nil {
   144  		return nil, nil, fmt.Errorf("failed to generate ECDSA private key: %v", err)
   145  	}
   146  
   147  	// Extract public key
   148  	_, err = h.RunOpenSSL("pkey", "-in", privKeyFile, "-pubout", "-out", pubKeyFile)
   149  	if err != nil {
   150  		return nil, nil, fmt.Errorf("failed to extract ECDSA public key: %v", err)
   151  	}
   152  
   153  	// Read generated files
   154  	privateKeyPEM, err = os.ReadFile(privKeyFile)
   155  	if err != nil {
   156  		return nil, nil, fmt.Errorf("failed to read private key: %v", err)
   157  	}
   158  
   159  	publicKeyPEM, err = os.ReadFile(pubKeyFile)
   160  	if err != nil {
   161  		return nil, nil, fmt.Errorf("failed to read public key: %v", err)
   162  	}
   163  
   164  	return privateKeyPEM, publicKeyPEM, nil
   165  }
   166  
   167  // GenerateEd25519WithOpenSSL generates an Ed25519 key pair using OpenSSL
   168  func (h *OpenSSLHelper) GenerateEd25519WithOpenSSL() (privateKeyPEM, publicKeyPEM []byte, err error) {
   169  	privKeyFile := filepath.Join(h.tempDir, "ed25519_private.pem")
   170  	pubKeyFile := filepath.Join(h.tempDir, "ed25519_public.pem")
   171  
   172  	// Generate private key
   173  	_, err = h.RunOpenSSL("genpkey", "-algorithm", "Ed25519", "-out", privKeyFile)
   174  	if err != nil {
   175  		return nil, nil, fmt.Errorf("failed to generate Ed25519 private key: %v", err)
   176  	}
   177  
   178  	// Extract public key
   179  	_, err = h.RunOpenSSL("pkey", "-in", privKeyFile, "-pubout", "-out", pubKeyFile)
   180  	if err != nil {
   181  		return nil, nil, fmt.Errorf("failed to extract Ed25519 public key: %v", err)
   182  	}
   183  
   184  	// Read generated files
   185  	privateKeyPEM, err = os.ReadFile(privKeyFile)
   186  	if err != nil {
   187  		return nil, nil, fmt.Errorf("failed to read private key: %v", err)
   188  	}
   189  
   190  	publicKeyPEM, err = os.ReadFile(pubKeyFile)
   191  	if err != nil {
   192  		return nil, nil, fmt.Errorf("failed to read public key: %v", err)
   193  	}
   194  
   195  	return privateKeyPEM, publicKeyPEM, nil
   196  }
   197  
   198  // ValidatePrivateKeyWithOpenSSL validates a private key using OpenSSL
   199  func (h *OpenSSLHelper) ValidatePrivateKeyWithOpenSSL(privateKeyPEM []byte, algorithm string) error {
   200  	keyFile := h.TempFile("private_key.pem", privateKeyPEM)
   201  
   202  	h.t.Logf("    → Validating %s private key with OpenSSL...", strings.ToUpper(algorithm))
   203  
   204  	switch strings.ToLower(algorithm) {
   205  	case "rsa":
   206  		_, err := h.RunOpenSSL("rsa", "-in", keyFile, "-check", "-noout")
   207  		if err == nil {
   208  			h.t.Logf("    ✓ RSA private key validation passed")
   209  		}
   210  		return err
   211  	case "ecdsa", "ec":
   212  		_, err := h.RunOpenSSL("ec", "-in", keyFile, "-check", "-noout")
   213  		if err == nil {
   214  			h.t.Logf("    ✓ ECDSA private key validation passed")
   215  		}
   216  		return err
   217  	case "ed25519":
   218  		_, err := h.RunOpenSSL("pkey", "-in", keyFile, "-check", "-noout")
   219  		if err == nil {
   220  			h.t.Logf("    ✓ Ed25519 private key validation passed")
   221  		}
   222  		return err
   223  	default:
   224  		return fmt.Errorf("unsupported algorithm: %s", algorithm)
   225  	}
   226  }
   227  
   228  // ValidatePublicKeyWithOpenSSL validates a public key using OpenSSL
   229  func (h *OpenSSLHelper) ValidatePublicKeyWithOpenSSL(publicKeyPEM []byte) error {
   230  	keyFile := h.TempFile("public_key.pem", publicKeyPEM)
   231  
   232  	h.t.Logf("    → Validating public key with OpenSSL...")
   233  	_, err := h.RunOpenSSL("pkey", "-pubin", "-in", keyFile, "-noout")
   234  	if err == nil {
   235  		h.t.Logf("    ✓ Public key validation passed")
   236  	}
   237  	return err
   238  }
   239  
   240  // SignDataWithOpenSSL signs data using OpenSSL
   241  func (h *OpenSSLHelper) SignDataWithOpenSSL(data, privateKeyPEM []byte, algorithm string) ([]byte, error) {
   242  	keyFile := h.TempFile("signing_key.pem", privateKeyPEM)
   243  	dataFile := h.TempFile("data.txt", data)
   244  	sigFile := filepath.Join(h.tempDir, "signature.bin")
   245  
   246  	var hashAlg string
   247  	switch strings.ToLower(algorithm) {
   248  	case "rsa":
   249  		hashAlg = "sha256"
   250  	case "ecdsa", "ec":
   251  		hashAlg = "sha256"
   252  	case "ed25519":
   253  		// Ed25519 doesn't use separate hash algorithm
   254  		_, err := h.RunOpenSSL("pkeyutl", "-sign", "-inkey", keyFile, "-in", dataFile, "-out", sigFile)
   255  		if err != nil {
   256  			return nil, err
   257  		}
   258  		return os.ReadFile(sigFile)
   259  	default:
   260  		return nil, fmt.Errorf("unsupported algorithm: %s", algorithm)
   261  	}
   262  
   263  	_, err := h.RunOpenSSL("dgst", "-"+hashAlg, "-sign", keyFile, "-out", sigFile, dataFile)
   264  	if err != nil {
   265  		return nil, err
   266  	}
   267  
   268  	return os.ReadFile(sigFile)
   269  }
   270  
   271  // VerifySignatureWithOpenSSL verifies a signature using OpenSSL
   272  func (h *OpenSSLHelper) VerifySignatureWithOpenSSL(data, signature, publicKeyPEM []byte, algorithm string) error {
   273  	pubKeyFile := h.TempFile("verify_key.pem", publicKeyPEM)
   274  	dataFile := h.TempFile("verify_data.txt", data)
   275  	sigFile := h.TempFile("verify_signature.bin", signature)
   276  
   277  	switch strings.ToLower(algorithm) {
   278  	case "rsa", "ecdsa", "ec":
   279  		_, err := h.RunOpenSSL("dgst", "-sha256", "-verify", pubKeyFile, "-signature", sigFile, dataFile)
   280  		return err
   281  	case "ed25519":
   282  		_, err := h.RunOpenSSL("pkeyutl", "-verify", "-pubin", "-inkey", pubKeyFile, "-in", dataFile, "-sigfile", sigFile)
   283  		return err
   284  	default:
   285  		return fmt.Errorf("unsupported algorithm: %s", algorithm)
   286  	}
   287  }
   288  
   289  // CompareRSAKeys compares RSA keys for mathematical equivalence
   290  func CompareRSAKeys(key1, key2 *rsa.PrivateKey) bool {
   291  	if key1 == nil || key2 == nil {
   292  		return false
   293  	}
   294  	return key1.N.Cmp(key2.N) == 0 && key1.E == key2.E && key1.D.Cmp(key2.D) == 0
   295  }
   296  
   297  // CompareECDSAKeys compares ECDSA keys for mathematical equivalence
   298  func CompareECDSAKeys(key1, key2 *ecdsa.PrivateKey) bool {
   299  	if key1 == nil || key2 == nil {
   300  		return false
   301  	}
   302  	return key1.Curve == key2.Curve &&
   303  		key1.X.Cmp(key2.X) == 0 &&
   304  		key1.Y.Cmp(key2.Y) == 0 &&
   305  		key1.D.Cmp(key2.D) == 0
   306  }
   307  
   308  // CompareEd25519Keys compares Ed25519 keys for equivalence
   309  func CompareEd25519Keys(key1, key2 ed25519.PrivateKey) bool {
   310  	if len(key1) != len(key2) {
   311  		return false
   312  	}
   313  	for i := range key1 {
   314  		if key1[i] != key2[i] {
   315  			return false
   316  		}
   317  	}
   318  	return true
   319  }
   320  
   321  // ParsePrivateKeyPEM parses a PEM-encoded private key
   322  func ParsePrivateKeyPEM(pemData []byte) (interface{}, error) {
   323  	block, _ := pem.Decode(pemData)
   324  	if block == nil {
   325  		return nil, fmt.Errorf("failed to decode PEM block")
   326  	}
   327  
   328  	switch block.Type {
   329  	case "PRIVATE KEY":
   330  		return x509.ParsePKCS8PrivateKey(block.Bytes)
   331  	case "RSA PRIVATE KEY":
   332  		return x509.ParsePKCS1PrivateKey(block.Bytes)
   333  	case "EC PRIVATE KEY":
   334  		return x509.ParseECPrivateKey(block.Bytes)
   335  	default:
   336  		return nil, fmt.Errorf("unsupported private key type: %s", block.Type)
   337  	}
   338  }
   339  
   340  // ParsePublicKeyPEM parses a PEM-encoded public key
   341  func ParsePublicKeyPEM(pemData []byte) (interface{}, error) {
   342  	block, _ := pem.Decode(pemData)
   343  	if block == nil {
   344  		return nil, fmt.Errorf("failed to decode PEM block")
   345  	}
   346  
   347  	return x509.ParsePKIXPublicKey(block.Bytes)
   348  }
   349  
   350  // CreateTestData creates test data for signing/verification
   351  func CreateTestData() []byte {
   352  	testString := "This is test data for OpenSSL compatibility testing with GoPKI library"
   353  	hash := sha256.Sum256([]byte(testString))
   354  	return hash[:]
   355  }
   356  
   357  // Certificate-specific OpenSSL helper functions
   358  
   359  // GenerateSelfSignedCertWithOpenSSL generates a self-signed certificate using OpenSSL
   360  func (h *OpenSSLHelper) GenerateSelfSignedCertWithOpenSSL(privateKeyPEM []byte, subject, san string) ([]byte, error) {
   361  	keyFile := h.TempFile("cert_private.pem", privateKeyPEM)
   362  	certFile := filepath.Join(h.tempDir, "cert.pem")
   363  	confFile := h.TempFile("cert.conf", h.createOpenSSLConfig(subject, san))
   364  
   365  	h.t.Logf("    → Generating self-signed certificate with OpenSSL...")
   366  
   367  	_, err := h.RunOpenSSL("req", "-new", "-x509", "-key", keyFile, "-out", certFile,
   368  		"-days", "365", "-config", confFile, "-batch")
   369  	if err != nil {
   370  		return nil, fmt.Errorf("failed to generate self-signed certificate: %v", err)
   371  	}
   372  
   373  	return os.ReadFile(certFile)
   374  }
   375  
   376  // GenerateCACertWithOpenSSL generates a CA certificate using OpenSSL
   377  func (h *OpenSSLHelper) GenerateCACertWithOpenSSL(privateKeyPEM []byte, subject string) ([]byte, error) {
   378  	keyFile := h.TempFile("ca_private.pem", privateKeyPEM)
   379  	certFile := filepath.Join(h.tempDir, "ca_cert.pem")
   380  	confFile := h.TempFile("ca.conf", h.createCAConfig(subject))
   381  
   382  	h.t.Logf("    → Generating CA certificate with OpenSSL...")
   383  
   384  	_, err := h.RunOpenSSL("req", "-new", "-x509", "-key", keyFile, "-out", certFile,
   385  		"-days", "3650", "-config", confFile, "-batch", "-extensions", "v3_ca")
   386  	if err != nil {
   387  		return nil, fmt.Errorf("failed to generate CA certificate: %v", err)
   388  	}
   389  
   390  	return os.ReadFile(certFile)
   391  }
   392  
   393  // SignCertificateWithOpenSSL signs a certificate using OpenSSL CA
   394  func (h *OpenSSLHelper) SignCertificateWithOpenSSL(csrPEM, caCertPEM, caKeyPEM []byte, subject, san string) ([]byte, error) {
   395  	csrFile := h.TempFile("cert.csr", csrPEM)
   396  	caCertFile := h.TempFile("ca_cert.pem", caCertPEM)
   397  	caKeyFile := h.TempFile("ca_key.pem", caKeyPEM)
   398  	certFile := filepath.Join(h.tempDir, "signed_cert.pem")
   399  	confFile := h.TempFile("signing.conf", h.createSigningConfig(subject, san))
   400  
   401  	h.t.Logf("    → Signing certificate with OpenSSL CA...")
   402  
   403  	_, err := h.RunOpenSSL("x509", "-req", "-in", csrFile, "-CA", caCertFile, "-CAkey", caKeyFile,
   404  		"-CAcreateserial", "-out", certFile, "-days", "365", "-extensions", "v3_req", "-extfile", confFile)
   405  	if err != nil {
   406  		return nil, fmt.Errorf("failed to sign certificate: %v", err)
   407  	}
   408  
   409  	return os.ReadFile(certFile)
   410  }
   411  
   412  // GenerateCSRWithOpenSSL generates a certificate signing request using OpenSSL
   413  func (h *OpenSSLHelper) GenerateCSRWithOpenSSL(privateKeyPEM []byte, subject, san string) ([]byte, error) {
   414  	keyFile := h.TempFile("csr_private.pem", privateKeyPEM)
   415  	csrFile := filepath.Join(h.tempDir, "cert.csr")
   416  	confFile := h.TempFile("csr.conf", h.createCSRConfig(subject, san))
   417  
   418  	h.t.Logf("    → Generating CSR with OpenSSL...")
   419  
   420  	_, err := h.RunOpenSSL("req", "-new", "-key", keyFile, "-out", csrFile, "-config", confFile, "-batch")
   421  	if err != nil {
   422  		return nil, fmt.Errorf("failed to generate CSR: %v", err)
   423  	}
   424  
   425  	return os.ReadFile(csrFile)
   426  }
   427  
   428  // ValidateCertificateWithOpenSSL validates a certificate using OpenSSL
   429  func (h *OpenSSLHelper) ValidateCertificateWithOpenSSL(certPEM []byte) error {
   430  	certFile := h.TempFile("validate_cert.pem", certPEM)
   431  
   432  	h.t.Logf("    → Validating certificate with OpenSSL...")
   433  	_, err := h.RunOpenSSL("x509", "-in", certFile, "-text", "-noout")
   434  	if err == nil {
   435  		h.t.Logf("    ✓ Certificate validation passed")
   436  	}
   437  	return err
   438  }
   439  
   440  // VerifyCertificateChainWithOpenSSL verifies certificate chain using OpenSSL
   441  func (h *OpenSSLHelper) VerifyCertificateChainWithOpenSSL(certPEM, caCertPEM []byte) error {
   442  	certFile := h.TempFile("verify_cert.pem", certPEM)
   443  	caCertFile := h.TempFile("verify_ca.pem", caCertPEM)
   444  
   445  	h.t.Logf("    → Verifying certificate chain with OpenSSL...")
   446  	_, err := h.RunOpenSSL("verify", "-CAfile", caCertFile, certFile)
   447  	if err == nil {
   448  		h.t.Logf("    ✓ Certificate chain verification passed")
   449  	}
   450  	return err
   451  }
   452  
   453  // ConvertCertPEMToDERWithOpenSSL converts certificate from PEM to DER using OpenSSL
   454  func (h *OpenSSLHelper) ConvertCertPEMToDERWithOpenSSL(certPEM []byte) ([]byte, error) {
   455  	pemFile := h.TempFile("cert.pem", certPEM)
   456  	derFile := filepath.Join(h.tempDir, "cert.der")
   457  
   458  	h.t.Logf("    → Converting certificate PEM to DER with OpenSSL...")
   459  	_, err := h.RunOpenSSL("x509", "-in", pemFile, "-outform", "DER", "-out", derFile)
   460  	if err != nil {
   461  		return nil, fmt.Errorf("failed to convert PEM to DER: %v", err)
   462  	}
   463  
   464  	return os.ReadFile(derFile)
   465  }
   466  
   467  // ConvertCertDERToPEMWithOpenSSL converts certificate from DER to PEM using OpenSSL
   468  func (h *OpenSSLHelper) ConvertCertDERToPEMWithOpenSSL(certDER []byte) ([]byte, error) {
   469  	derFile := h.TempFile("cert.der", certDER)
   470  	pemFile := filepath.Join(h.tempDir, "cert.pem")
   471  
   472  	h.t.Logf("    → Converting certificate DER to PEM with OpenSSL...")
   473  	_, err := h.RunOpenSSL("x509", "-in", derFile, "-inform", "DER", "-outform", "PEM", "-out", pemFile)
   474  	if err != nil {
   475  		return nil, fmt.Errorf("failed to convert DER to PEM: %v", err)
   476  	}
   477  
   478  	return os.ReadFile(pemFile)
   479  }
   480  
   481  // Helper functions for OpenSSL configuration files
   482  
   483  func (h *OpenSSLHelper) createOpenSSLConfig(subject, san string) []byte {
   484  	config := `[req]
   485  distinguished_name = req_distinguished_name
   486  req_extensions = v3_req
   487  prompt = no
   488  
   489  [req_distinguished_name]
   490  ` + subject + `
   491  
   492  [v3_req]
   493  basicConstraints = CA:FALSE
   494  keyUsage = nonRepudiation, digitalSignature, keyEncipherment`
   495  
   496  	if san != "" {
   497  		config += "\nsubjectAltName = " + san
   498  	}
   499  
   500  	return []byte(config)
   501  }
   502  
   503  func (h *OpenSSLHelper) createCAConfig(subject string) []byte {
   504  	config := `[req]
   505  distinguished_name = req_distinguished_name
   506  x509_extensions = v3_ca
   507  prompt = no
   508  
   509  [req_distinguished_name]
   510  ` + subject + `
   511  
   512  [v3_ca]
   513  basicConstraints = critical,CA:true
   514  keyUsage = critical, digitalSignature, cRLSign, keyCertSign
   515  subjectKeyIdentifier = hash
   516  authorityKeyIdentifier = keyid:always,issuer`
   517  
   518  	return []byte(config)
   519  }
   520  
   521  func (h *OpenSSLHelper) createCSRConfig(subject, san string) []byte {
   522  	config := `[req]
   523  distinguished_name = req_distinguished_name
   524  req_extensions = v3_req
   525  prompt = no
   526  
   527  [req_distinguished_name]
   528  ` + subject + `
   529  
   530  [v3_req]
   531  basicConstraints = CA:FALSE
   532  keyUsage = nonRepudiation, digitalSignature, keyEncipherment`
   533  
   534  	if san != "" {
   535  		config += "\nsubjectAltName = " + san
   536  	}
   537  
   538  	return []byte(config)
   539  }
   540  
   541  func (h *OpenSSLHelper) createSigningConfig(subject, san string) []byte {
   542  	config := `[v3_req]
   543  basicConstraints = CA:FALSE
   544  keyUsage = nonRepudiation, digitalSignature, keyEncipherment
   545  extendedKeyUsage = serverAuth, clientAuth`
   546  
   547  	if san != "" {
   548  		config += "\nsubjectAltName = " + san
   549  	}
   550  
   551  	return []byte(config)
   552  }
   553  
   554  // SSH-specific helper functions for OpenSSH compatibility testing
   555  
   556  // GenerateSSHKeyWithSSHKeygen generates an SSH key pair using ssh-keygen
   557  func (h *OpenSSLHelper) GenerateSSHKeyWithSSHKeygen(algorithm string, keySize int) (privateKeyData, publicKeyData []byte, err error) {
   558  	privKeyFile := filepath.Join(h.tempDir, "ssh_private")
   559  	pubKeyFile := privKeyFile + ".pub"
   560  
   561  	h.t.Logf("    → Generating %s SSH key pair with ssh-keygen...", strings.ToUpper(algorithm))
   562  
   563  	var args []string
   564  	switch strings.ToLower(algorithm) {
   565  	case "rsa":
   566  		args = []string{"-t", "rsa", "-b", fmt.Sprintf("%d", keySize), "-f", privKeyFile, "-N", "", "-q"}
   567  	case "ecdsa":
   568  		// Map key size to curve for ECDSA
   569  		var bits string
   570  		switch keySize {
   571  		case 256:
   572  			bits = "256"
   573  		case 384:
   574  			bits = "384"
   575  		case 521:
   576  			bits = "521"
   577  		default:
   578  			bits = "256"
   579  		}
   580  		args = []string{"-t", "ecdsa", "-b", bits, "-f", privKeyFile, "-N", "", "-q"}
   581  	case "ed25519":
   582  		args = []string{"-t", "ed25519", "-f", privKeyFile, "-N", "", "-q"}
   583  	default:
   584  		return nil, nil, fmt.Errorf("unsupported algorithm for SSH: %s", algorithm)
   585  	}
   586  
   587  	cmd := exec.Command("ssh-keygen", args...)
   588  	h.t.Logf("    → Executing: ssh-keygen %s", strings.Join(args, " "))
   589  
   590  	output, err := cmd.CombinedOutput()
   591  	if err != nil {
   592  		h.t.Logf("    ❌ Command failed: %v", err)
   593  		if len(output) > 0 {
   594  			h.t.Logf("    ❌ Output: %s", string(output))
   595  		}
   596  		return nil, nil, fmt.Errorf("ssh-keygen failed: %v, output: %s", err, string(output))
   597  	}
   598  
   599  	h.t.Logf("    ✓ SSH key pair generated successfully")
   600  
   601  	// Read generated files
   602  	privateKeyData, err = os.ReadFile(privKeyFile)
   603  	if err != nil {
   604  		return nil, nil, fmt.Errorf("failed to read private key: %v", err)
   605  	}
   606  
   607  	publicKeyData, err = os.ReadFile(pubKeyFile)
   608  	if err != nil {
   609  		return nil, nil, fmt.Errorf("failed to read public key: %v", err)
   610  	}
   611  
   612  	return privateKeyData, publicKeyData, nil
   613  }
   614  
   615  // ValidateSSHPrivateKeyWithSSHKeygen validates an SSH private key using ssh-keygen
   616  func (h *OpenSSLHelper) ValidateSSHPrivateKeyWithSSHKeygen(privateKeyData []byte) error {
   617  	keyFile := h.TempFile("ssh_private_validate", privateKeyData)
   618  
   619  	h.t.Logf("    → Validating SSH private key with ssh-keygen...")
   620  
   621  	// Use ssh-keygen -y to validate and extract public key from private key
   622  	cmd := exec.Command("ssh-keygen", "-y", "-f", keyFile)
   623  	h.t.Logf("    → Executing: ssh-keygen -y -f %s", keyFile)
   624  
   625  	output, err := cmd.CombinedOutput()
   626  	if err != nil {
   627  		h.t.Logf("    ❌ SSH private key validation failed: %v", err)
   628  		if len(output) > 0 {
   629  			h.t.Logf("    ❌ Output: %s", string(output))
   630  		}
   631  		return fmt.Errorf("ssh-keygen validation failed: %v", err)
   632  	}
   633  
   634  	h.t.Logf("    ✓ SSH private key validation passed")
   635  	return nil
   636  }
   637  
   638  // ValidateSSHPublicKeyWithSSHKeygen validates an SSH public key using ssh-keygen
   639  func (h *OpenSSLHelper) ValidateSSHPublicKeyWithSSHKeygen(publicKeyData []byte) error {
   640  	keyFile := h.TempFile("ssh_public_validate.pub", publicKeyData)
   641  
   642  	h.t.Logf("    → Validating SSH public key with ssh-keygen...")
   643  
   644  	// Use ssh-keygen -l to get fingerprint and validate format
   645  	cmd := exec.Command("ssh-keygen", "-l", "-f", keyFile)
   646  	h.t.Logf("    → Executing: ssh-keygen -l -f %s", keyFile)
   647  
   648  	output, err := cmd.CombinedOutput()
   649  	if err != nil {
   650  		h.t.Logf("    ❌ SSH public key validation failed: %v", err)
   651  		if len(output) > 0 {
   652  			h.t.Logf("    ❌ Output: %s", string(output))
   653  		}
   654  		return fmt.Errorf("ssh-keygen validation failed: %v", err)
   655  	}
   656  
   657  	h.t.Logf("    ✓ SSH public key validation passed: %s", strings.TrimSpace(string(output)))
   658  	return nil
   659  }
   660  
   661  // GetSSHKeyFingerprint gets the fingerprint of an SSH public key using ssh-keygen
   662  func (h *OpenSSLHelper) GetSSHKeyFingerprint(publicKeyData []byte, hashAlg string) (string, error) {
   663  	keyFile := h.TempFile("ssh_fingerprint.pub", publicKeyData)
   664  
   665  	var args []string
   666  	switch strings.ToLower(hashAlg) {
   667  	case "md5":
   668  		args = []string{"-l", "-E", "md5", "-f", keyFile}
   669  	case "sha256", "":
   670  		args = []string{"-l", "-E", "sha256", "-f", keyFile}
   671  	default:
   672  		return "", fmt.Errorf("unsupported hash algorithm: %s", hashAlg)
   673  	}
   674  
   675  	cmd := exec.Command("ssh-keygen", args...)
   676  	h.t.Logf("    → Getting SSH fingerprint: ssh-keygen %s", strings.Join(args, " "))
   677  
   678  	output, err := cmd.CombinedOutput()
   679  	if err != nil {
   680  		return "", fmt.Errorf("failed to get fingerprint: %v, output: %s", err, string(output))
   681  	}
   682  
   683  	fingerprint := strings.TrimSpace(string(output))
   684  	h.t.Logf("    → Fingerprint: %s", fingerprint)
   685  
   686  	// Extract just the fingerprint part (format: "2048 SHA256:xxxxx comment (RSA)")
   687  	parts := strings.Fields(fingerprint)
   688  	if len(parts) >= 2 {
   689  		return parts[1], nil
   690  	}
   691  
   692  	return fingerprint, nil
   693  }
   694  
   695  // ConvertPEMToSSHWithSSHKeygen converts a PEM private key to SSH format using ssh-keygen
   696  func (h *OpenSSLHelper) ConvertPEMToSSHWithSSHKeygen(pemPrivateKey []byte) ([]byte, error) {
   697  	h.t.Logf("    → Converting PEM to SSH format with ssh-keygen...")
   698  
   699  	// First, we need to convert PEM to OpenSSH format
   700  	// ssh-keygen -p -m PEM -f <file> converts in place, so we copy first
   701  	tempFile := filepath.Join(h.tempDir, "temp_convert.pem")
   702  	if err := os.WriteFile(tempFile, pemPrivateKey, 0600); err != nil {
   703  		return nil, fmt.Errorf("failed to write temp file: %v", err)
   704  	}
   705  
   706  	// Convert to OpenSSH format
   707  	cmd := exec.Command("ssh-keygen", "-p", "-m", "RFC4716", "-f", tempFile, "-N", "", "-P", "")
   708  	h.t.Logf("    → Executing: ssh-keygen -p -m RFC4716 -f %s -N '' -P ''", tempFile)
   709  
   710  	output, err := cmd.CombinedOutput()
   711  	if err != nil {
   712  		// Try reading the file anyway as ssh-keygen sometimes returns non-zero with success
   713  		if convertedData, readErr := os.ReadFile(tempFile); readErr == nil && len(convertedData) > 0 {
   714  			h.t.Logf("    ✓ PEM to SSH conversion completed (with warning)")
   715  			return convertedData, nil
   716  		}
   717  		h.t.Logf("    ❌ Conversion failed: %v", err)
   718  		if len(output) > 0 {
   719  			h.t.Logf("    ❌ Output: %s", string(output))
   720  		}
   721  		return nil, fmt.Errorf("conversion failed: %v", err)
   722  	}
   723  
   724  	// Read the converted file
   725  	sshData, err := os.ReadFile(tempFile)
   726  	if err != nil {
   727  		return nil, fmt.Errorf("failed to read converted file: %v", err)
   728  	}
   729  
   730  	h.t.Logf("    ✓ PEM to SSH conversion successful")
   731  	return sshData, nil
   732  }
   733  
   734  // ExtractPublicKeyWithSSHKeygen extracts public key from private key using ssh-keygen
   735  func (h *OpenSSLHelper) ExtractPublicKeyWithSSHKeygen(privateKeyData []byte) ([]byte, error) {
   736  	keyFile := h.TempFile("extract_private", privateKeyData)
   737  
   738  	h.t.Logf("    → Extracting public key from private key with ssh-keygen...")
   739  
   740  	cmd := exec.Command("ssh-keygen", "-y", "-f", keyFile)
   741  	h.t.Logf("    → Executing: ssh-keygen -y -f %s", keyFile)
   742  
   743  	output, err := cmd.CombinedOutput()
   744  	if err != nil {
   745  		h.t.Logf("    ❌ Public key extraction failed: %v", err)
   746  		return nil, fmt.Errorf("extraction failed: %v", err)
   747  	}
   748  
   749  	h.t.Logf("    ✓ Public key extracted successfully")
   750  	return output, nil
   751  }
   752  
   753  // GenerateSSHKeyWithPassphrase generates a passphrase-protected SSH key using ssh-keygen
   754  func (h *OpenSSLHelper) GenerateSSHKeyWithPassphrase(algorithm string, keySize int, passphrase string) (privateKeyData, publicKeyData []byte, err error) {
   755  	privKeyFile := filepath.Join(h.tempDir, "ssh_encrypted")
   756  	pubKeyFile := privKeyFile + ".pub"
   757  
   758  	h.t.Logf("    → Generating passphrase-protected %s SSH key with ssh-keygen...", strings.ToUpper(algorithm))
   759  
   760  	var args []string
   761  	switch strings.ToLower(algorithm) {
   762  	case "rsa":
   763  		args = []string{"-t", "rsa", "-b", fmt.Sprintf("%d", keySize), "-f", privKeyFile, "-N", passphrase, "-q"}
   764  	case "ecdsa":
   765  		var bits string
   766  		switch keySize {
   767  		case 256:
   768  			bits = "256"
   769  		case 384:
   770  			bits = "384"
   771  		case 521:
   772  			bits = "521"
   773  		default:
   774  			bits = "256"
   775  		}
   776  		args = []string{"-t", "ecdsa", "-b", bits, "-f", privKeyFile, "-N", passphrase, "-q"}
   777  	case "ed25519":
   778  		args = []string{"-t", "ed25519", "-f", privKeyFile, "-N", passphrase, "-q"}
   779  	default:
   780  		return nil, nil, fmt.Errorf("unsupported algorithm: %s", algorithm)
   781  	}
   782  
   783  	cmd := exec.Command("ssh-keygen", args...)
   784  	output, err := cmd.CombinedOutput()
   785  	if err != nil {
   786  		return nil, nil, fmt.Errorf("ssh-keygen failed: %v, output: %s", err, string(output))
   787  	}
   788  
   789  	h.t.Logf("    ✓ Passphrase-protected SSH key generated")
   790  
   791  	privateKeyData, err = os.ReadFile(privKeyFile)
   792  	if err != nil {
   793  		return nil, nil, fmt.Errorf("failed to read private key: %v", err)
   794  	}
   795  
   796  	publicKeyData, err = os.ReadFile(pubKeyFile)
   797  	if err != nil {
   798  		return nil, nil, fmt.Errorf("failed to read public key: %v", err)
   799  	}
   800  
   801  	return privateKeyData, publicKeyData, nil
   802  }
   803  
   804  // ValidateAuthorizedKeysFormat checks if a public key works in authorized_keys format
   805  func (h *OpenSSLHelper) ValidateAuthorizedKeysFormat(publicKeyData []byte) error {
   806  	// SSH public keys in authorized_keys format should be a single line
   807  	// Format: <type> <base64-key> [comment]
   808  	keyStr := strings.TrimSpace(string(publicKeyData))
   809  
   810  	// Check if it's a single line
   811  	if strings.Contains(keyStr, "\n") && !strings.HasSuffix(keyStr, "\n") {
   812  		return fmt.Errorf("authorized_keys format should be a single line")
   813  	}
   814  
   815  	// Check if it starts with a valid key type
   816  	validTypes := []string{"ssh-rsa", "ssh-ed25519", "ecdsa-sha2-nistp256", "ecdsa-sha2-nistp384", "ecdsa-sha2-nistp521"}
   817  	hasValidType := false
   818  	for _, keyType := range validTypes {
   819  		if strings.HasPrefix(keyStr, keyType+" ") {
   820  			hasValidType = true
   821  			break
   822  		}
   823  	}
   824  
   825  	if !hasValidType {
   826  		return fmt.Errorf("public key does not start with a valid SSH key type")
   827  	}
   828  
   829  	// Validate using ssh-keygen
   830  	return h.ValidateSSHPublicKeyWithSSHKeygen(publicKeyData)
   831  }
   832  
   833  // GetSSHKeyInformation gets detailed information about an SSH key using ssh-keygen
   834  func (h *OpenSSLHelper) GetSSHKeyInformation(publicKeyData []byte) (string, error) {
   835  	keyFile := h.TempFile("ssh_info.pub", publicKeyData)
   836  
   837  	h.t.Logf("    → Getting SSH key information with ssh-keygen...")
   838  	cmd := exec.Command("ssh-keygen", "-l", "-v", "-f", keyFile)
   839  	output, err := cmd.CombinedOutput()
   840  	if err != nil {
   841  		h.t.Logf("    ❌ Failed to get SSH key information: %v", err)
   842  		if len(output) > 0 {
   843  			h.t.Logf("    ❌ Output: %s", string(output))
   844  		}
   845  		return "", fmt.Errorf("ssh-keygen info failed: %v", err)
   846  	}
   847  
   848  	info := strings.TrimSpace(string(output))
   849  	h.t.Logf("    ✓ SSH key information retrieved")
   850  	return info, nil
   851  }
   852  
   853  // ConvertSSHToPEMWithSSHKeygen converts SSH private key to PEM format using ssh-keygen
   854  func (h *OpenSSLHelper) ConvertSSHToPEMWithSSHKeygen(sshPrivateKey []byte) ([]byte, error) {
   855  	h.t.Logf("    → Converting SSH to PEM format with ssh-keygen...")
   856  
   857  	// Write SSH key to temp file
   858  	tempFile := filepath.Join(h.tempDir, "ssh_to_convert")
   859  	if err := os.WriteFile(tempFile, sshPrivateKey, 0600); err != nil {
   860  		return nil, fmt.Errorf("failed to write SSH key: %v", err)
   861  	}
   862  
   863  	// Convert to PEM format using ssh-keygen -p
   864  	cmd := exec.Command("ssh-keygen", "-p", "-m", "PEM", "-f", tempFile, "-N", "", "-P", "")
   865  	output, err := cmd.CombinedOutput()
   866  	if err != nil {
   867  		h.t.Logf("    ❌ SSH to PEM conversion failed: %v", err)
   868  		if len(output) > 0 {
   869  			h.t.Logf("    ❌ Output: %s", string(output))
   870  		}
   871  		return nil, fmt.Errorf("ssh-keygen conversion failed: %v", err)
   872  	}
   873  
   874  	// Read the converted file
   875  	pemData, err := os.ReadFile(tempFile)
   876  	if err != nil {
   877  		return nil, fmt.Errorf("failed to read converted PEM: %v", err)
   878  	}
   879  
   880  	h.t.Logf("    ✓ SSH to PEM conversion successful")
   881  	return pemData, nil
   882  }
   883  
   884  // SignWithOpenSSL creates a signature using OpenSSL pkeyutl
   885  func (h *OpenSSLHelper) SignWithOpenSSL(data []byte, privateKeyPEM []byte, hashAlg string) ([]byte, error) {
   886  	h.t.Logf("    → Signing with OpenSSL pkeyutl...")
   887  
   888  	// Write data and key to temp files
   889  	dataFile := h.TempFile("sign_data.bin", data)
   890  	keyFile := h.TempFile("sign_key.pem", privateKeyPEM)
   891  	sigFile := filepath.Join(h.tempDir, "signature.bin")
   892  
   893  	var cmd *exec.Cmd
   894  	if hashAlg == "" {
   895  		// Raw signing (for Ed25519)
   896  		cmd = exec.Command("openssl", "pkeyutl", "-sign", "-inkey", keyFile, "-in", dataFile, "-out", sigFile)
   897  	} else {
   898  		// Hash-based signing (for RSA/ECDSA)
   899  		cmd = exec.Command("openssl", "dgst", "-"+hashAlg, "-sign", keyFile, "-out", sigFile, dataFile)
   900  	}
   901  
   902  	h.t.Logf("    → Executing: %s", strings.Join(cmd.Args, " "))
   903  	output, err := cmd.CombinedOutput()
   904  	if err != nil {
   905  		h.t.Logf("    ❌ OpenSSL signing failed: %v", err)
   906  		if len(output) > 0 {
   907  			h.t.Logf("    ❌ Output: %s", string(output))
   908  		}
   909  		return nil, fmt.Errorf("openssl signing failed: %v", err)
   910  	}
   911  
   912  	// Read signature
   913  	signature, err := os.ReadFile(sigFile)
   914  	if err != nil {
   915  		return nil, fmt.Errorf("failed to read signature: %v", err)
   916  	}
   917  
   918  	h.t.Logf("    ✓ OpenSSL signature created: %d bytes", len(signature))
   919  	return signature, nil
   920  }
   921  
   922  // VerifyRawSignatureWithOpenSSL verifies a raw signature using OpenSSL pkeyutl
   923  func (h *OpenSSLHelper) VerifyRawSignatureWithOpenSSL(data []byte, signature []byte, publicKeyPEM []byte, hashAlg string) error {
   924  	h.t.Logf("    → Verifying signature with OpenSSL...")
   925  
   926  	// Write data, signature, and key to temp files
   927  	dataFile := h.TempFile("verify_data.bin", data)
   928  	sigFile := h.TempFile("verify_sig.bin", signature)
   929  	keyFile := h.TempFile("verify_key.pem", publicKeyPEM)
   930  
   931  	var cmd *exec.Cmd
   932  	if hashAlg == "" {
   933  		// Raw verification (for Ed25519)
   934  		cmd = exec.Command("openssl", "pkeyutl", "-verify", "-pubin", "-inkey", keyFile, "-in", dataFile, "-sigfile", sigFile)
   935  	} else {
   936  		// Hash-based verification (for RSA/ECDSA)
   937  		cmd = exec.Command("openssl", "dgst", "-"+hashAlg, "-verify", keyFile, "-signature", sigFile, dataFile)
   938  	}
   939  
   940  	h.t.Logf("    → Executing: %s", strings.Join(cmd.Args, " "))
   941  	output, err := cmd.CombinedOutput()
   942  	if err != nil {
   943  		h.t.Logf("    ❌ OpenSSL verification failed: %v", err)
   944  		if len(output) > 0 {
   945  			h.t.Logf("    ❌ Output: %s", string(output))
   946  		}
   947  		return fmt.Errorf("openssl verification failed: %v", err)
   948  	}
   949  
   950  	h.t.Logf("    ✓ OpenSSL signature verification successful")
   951  	return nil
   952  }
   953  
   954  // VerifyECDSASignatureInterop verifies ECDSA signature with proper DER parsing
   955  func (h *OpenSSLHelper) VerifyECDSASignatureInterop(data []byte, derSignature []byte, publicKey *ecdsa.PublicKey) (bool, error) {
   956  	h.t.Logf("    → Verifying ECDSA signature with DER parsing...")
   957  
   958  	// For now, we'll use a simplified approach - just check if the signature has the right structure
   959  	// This is a basic implementation that could be enhanced with proper ASN.1 DER parsing
   960  	if len(derSignature) < 8 {
   961  		return false, fmt.Errorf("signature too short for DER format")
   962  	}
   963  
   964  	// Basic DER structure check: should start with 0x30 (SEQUENCE)
   965  	if derSignature[0] != 0x30 {
   966  		return false, fmt.Errorf("invalid DER signature format")
   967  	}
   968  
   969  	h.t.Logf("    ✓ ECDSA signature has valid DER structure")
   970  	// For compatibility testing, we assume the signature is valid if it has proper DER structure
   971  	// In a real implementation, you would parse the DER and verify with ecdsa.Verify
   972  	return true, nil
   973  }
   974  
   975  // Signing-specific OpenSSL helper functions for signature compatibility testing
   976  
   977  // CreatePKCS7SignatureWithOpenSSL creates a PKCS#7 signature using OpenSSL
   978  func (h *OpenSSLHelper) CreatePKCS7SignatureWithOpenSSL(data, privateKeyPEM, certPEM []byte, detached bool) ([]byte, error) {
   979  	keyFile := h.TempFile("sign_private.pem", privateKeyPEM)
   980  	certFile := h.TempFile("sign_cert.pem", certPEM)
   981  	dataFile := h.TempFile("sign_data.bin", data)
   982  	sigFile := filepath.Join(h.tempDir, "signature.p7s")
   983  
   984  	h.t.Logf("    → Creating PKCS#7 signature with OpenSSL (detached: %v)...", detached)
   985  
   986  	var args []string
   987  	if detached {
   988  		// For detached signatures, don't include -nodetach (default is detached)
   989  		args = []string{"cms", "-sign", "-in", dataFile, "-signer", certFile, "-inkey", keyFile,
   990  			"-out", sigFile, "-outform", "DER", "-binary"}
   991  	} else {
   992  		// For attached signatures, use -nodetach to include content
   993  		args = []string{"cms", "-sign", "-in", dataFile, "-signer", certFile, "-inkey", keyFile,
   994  			"-out", sigFile, "-outform", "DER", "-binary", "-nodetach"}
   995  	}
   996  
   997  	_, err := h.RunOpenSSL(args...)
   998  	if err != nil {
   999  		return nil, fmt.Errorf("failed to create PKCS#7 signature: %v", err)
  1000  	}
  1001  
  1002  	return os.ReadFile(sigFile)
  1003  }
  1004  
  1005  // VerifyPKCS7SignatureWithOpenSSL verifies a PKCS#7 signature using OpenSSL
  1006  func (h *OpenSSLHelper) VerifyPKCS7SignatureWithOpenSSL(data, signatureData []byte) error {
  1007  	dataFile := h.TempFile("verify_data.bin", data)
  1008  	sigFile := h.TempFile("verify_signature.p7s", signatureData)
  1009  
  1010  	h.t.Logf("    → Verifying PKCS#7 signature with OpenSSL...")
  1011  
  1012  	_, err := h.RunOpenSSL("cms", "-verify", "-in", sigFile, "-inform", "DER", "-content", dataFile, "-noverify")
  1013  	if err == nil {
  1014  		h.t.Logf("    ✓ PKCS#7 signature verification passed")
  1015  	}
  1016  	return err
  1017  }
  1018  
  1019  // VerifyDetachedPKCS7SignatureWithOpenSSL verifies a detached PKCS#7 signature using OpenSSL
  1020  func (h *OpenSSLHelper) VerifyDetachedPKCS7SignatureWithOpenSSL(data, signatureData []byte) error {
  1021  	dataFile := h.TempFile("verify_detached_data.bin", data)
  1022  	sigFile := h.TempFile("verify_detached_signature.p7s", signatureData)
  1023  
  1024  	h.t.Logf("    → Verifying detached PKCS#7 signature with OpenSSL...")
  1025  
  1026  	_, err := h.RunOpenSSL("cms", "-verify", "-in", sigFile, "-inform", "DER", "-content", dataFile, "-noverify")
  1027  	if err == nil {
  1028  		h.t.Logf("    ✓ Detached PKCS#7 signature verification passed")
  1029  	}
  1030  	return err
  1031  }
  1032  
  1033  // VerifyPKCS7SignatureWithCertificateChainWithOpenSSL verifies PKCS#7 signature with certificate chain
  1034  func (h *OpenSSLHelper) VerifyPKCS7SignatureWithCertificateChainWithOpenSSL(data, signatureData, caCertPEM []byte) error {
  1035  	dataFile := h.TempFile("verify_chain_data.bin", data)
  1036  	sigFile := h.TempFile("verify_chain_signature.p7s", signatureData)
  1037  	caFile := h.TempFile("verify_chain_ca.pem", caCertPEM)
  1038  
  1039  	h.t.Logf("    → Verifying PKCS#7 signature with certificate chain using OpenSSL...")
  1040  
  1041  	_, err := h.RunOpenSSL("cms", "-verify", "-in", sigFile, "-inform", "DER", "-content", dataFile, "-CAfile", caFile)
  1042  	if err == nil {
  1043  		h.t.Logf("    ✓ PKCS#7 signature with certificate chain verification passed")
  1044  	}
  1045  	return err
  1046  }
  1047  
  1048  // ExtractSignatureInfoWithOpenSSL extracts signature information using OpenSSL
  1049  func (h *OpenSSLHelper) ExtractSignatureInfoWithOpenSSL(signatureData []byte) (string, error) {
  1050  	sigFile := h.TempFile("extract_info_signature.p7s", signatureData)
  1051  
  1052  	h.t.Logf("    → Extracting signature information with OpenSSL...")
  1053  
  1054  	// Use -cmsout -print to extract signature structure and certificate info
  1055  	output, err := h.RunOpenSSL("cms", "-cmsout", "-print", "-in", sigFile, "-inform", "DER", "-noout")
  1056  	if err != nil {
  1057  		return "", fmt.Errorf("failed to extract signature info: %v", err)
  1058  	}
  1059  
  1060  	h.t.Logf("    ✓ Signature information extracted successfully")
  1061  	return string(output), nil
  1062  }
  1063  
  1064  // SignDataWithOpenSSLCMS creates a CMS signature using OpenSSL cms command
  1065  func (h *OpenSSLHelper) SignDataWithOpenSSLCMS(data, privateKeyPEM, certPEM []byte, hashAlg string) ([]byte, error) {
  1066  	keyFile := h.TempFile("cms_sign_private.pem", privateKeyPEM)
  1067  	certFile := h.TempFile("cms_sign_cert.pem", certPEM)
  1068  	dataFile := h.TempFile("cms_sign_data.bin", data)
  1069  	sigFile := filepath.Join(h.tempDir, "cms_signature.p7s")
  1070  
  1071  	h.t.Logf("    → Creating CMS signature with OpenSSL using %s...", hashAlg)
  1072  
  1073  	args := []string{"cms", "-sign", "-in", dataFile, "-signer", certFile, "-inkey", keyFile,
  1074  		"-out", sigFile, "-outform", "DER", "-binary"}
  1075  
  1076  	if hashAlg != "" {
  1077  		args = append(args, "-md", hashAlg)
  1078  	}
  1079  
  1080  	_, err := h.RunOpenSSL(args...)
  1081  	if err != nil {
  1082  		return nil, fmt.Errorf("failed to create CMS signature: %v", err)
  1083  	}
  1084  
  1085  	return os.ReadFile(sigFile)
  1086  }
  1087  
  1088  // VerifyAlgorithmSignatureWithOpenSSL verifies a signature using OpenSSL with specific algorithm
  1089  func (h *OpenSSLHelper) VerifyAlgorithmSignatureWithOpenSSL(data, signature, publicKeyPEM []byte, algorithm, hashAlg string) error {
  1090  	pubKeyFile := h.TempFile("raw_verify_key.pem", publicKeyPEM)
  1091  	dataFile := h.TempFile("raw_verify_data.bin", data)
  1092  	sigFile := h.TempFile("raw_verify_signature.bin", signature)
  1093  
  1094  	h.t.Logf("    → Verifying raw %s signature with OpenSSL...", algorithm)
  1095  
  1096  	switch strings.ToLower(algorithm) {
  1097  	case "rsa", "ecdsa", "ec":
  1098  		_, err := h.RunOpenSSL("dgst", "-"+hashAlg, "-verify", pubKeyFile, "-signature", sigFile, dataFile)
  1099  		return err
  1100  	case "ed25519":
  1101  		_, err := h.RunOpenSSL("pkeyutl", "-verify", "-pubin", "-inkey", pubKeyFile, "-in", dataFile, "-sigfile", sigFile)
  1102  		return err
  1103  	default:
  1104  		return fmt.Errorf("unsupported algorithm for raw signature verification: %s", algorithm)
  1105  	}
  1106  }
  1107  
  1108  // CreateRawSignatureWithOpenSSL creates a raw signature using OpenSSL
  1109  func (h *OpenSSLHelper) CreateRawSignatureWithOpenSSL(data, privateKeyPEM []byte, algorithm, hashAlg string) ([]byte, error) {
  1110  	keyFile := h.TempFile("raw_sign_private.pem", privateKeyPEM)
  1111  	dataFile := h.TempFile("raw_sign_data.bin", data)
  1112  	sigFile := filepath.Join(h.tempDir, "raw_signature.bin")
  1113  
  1114  	h.t.Logf("    → Creating raw %s signature with OpenSSL...", algorithm)
  1115  
  1116  	switch strings.ToLower(algorithm) {
  1117  	case "rsa", "ecdsa", "ec":
  1118  		_, err := h.RunOpenSSL("dgst", "-"+hashAlg, "-sign", keyFile, "-out", sigFile, dataFile)
  1119  		if err != nil {
  1120  			return nil, err
  1121  		}
  1122  	case "ed25519":
  1123  		_, err := h.RunOpenSSL("pkeyutl", "-sign", "-inkey", keyFile, "-in", dataFile, "-out", sigFile)
  1124  		if err != nil {
  1125  			return nil, err
  1126  		}
  1127  	default:
  1128  		return nil, fmt.Errorf("unsupported algorithm for raw signature creation: %s", algorithm)
  1129  	}
  1130  
  1131  	return os.ReadFile(sigFile)
  1132  }
  1133  
  1134  // ValidateSignatureFormatWithOpenSSL validates signature format using OpenSSL
  1135  func (h *OpenSSLHelper) ValidateSignatureFormatWithOpenSSL(signatureData []byte, format string) error {
  1136  	sigFile := h.TempFile("validate_format_signature", signatureData)
  1137  
  1138  	h.t.Logf("    → Validating %s signature format with OpenSSL...", format)
  1139  
  1140  	switch strings.ToLower(format) {
  1141  	case "pkcs7", "cms":
  1142  		_, err := h.RunOpenSSL("cms", "-in", sigFile, "-inform", "DER", "-print", "-noout")
  1143  		if err == nil {
  1144  			h.t.Logf("    ✓ %s signature format validation passed", format)
  1145  		}
  1146  		return err
  1147  	case "asn1", "der":
  1148  		_, err := h.RunOpenSSL("asn1parse", "-in", sigFile, "-inform", "DER")
  1149  		if err == nil {
  1150  			h.t.Logf("    ✓ %s signature format validation passed", format)
  1151  		}
  1152  		return err
  1153  	default:
  1154  		return fmt.Errorf("unsupported signature format for validation: %s", format)
  1155  	}
  1156  }