// Sign signs digest with the private key, possibly using entropy from
	// rand. For an RSA key, the resulting signature should be either a
	// PKCS #1 v1.5 or PSS signature (as indicated by opts). For an (EC)DSA
	// key, it should be a DER-serialised, ASN.1 signature structure.
	//
	// Hash implements the SignerOpts interface and, in most cases, one can
	// simply pass in the hash function used as opts. Sign may also attempt

	RET

// func svcCall(fnptr unsafe.Pointer, argv *unsafe.Pointer, dsa *uint64)
TEXT ·svcCall(SB), NOSPLIT, $0
	BL   runtime·save_g(SB)     // Save g and stack pointer
	MOVW PSALAA, R8
	MOVD LCA64(R8), R8
	MOVD SAVSTACK_ASYNC(R8), R9
	MOVD R15, 0(R9)

	MOVD argv+8(FP), R1   // Move function arguments into registers
	MOVD dsa+16(FP), g
	MOVD fnptr+0(FP), R15

	BYTE $0x0D // Branch to function
	BYTE $0xEF

        signatureSubpacketGenerator.setKeyFlags(false, KeyFlags.SIGN_DATA | KeyFlags.CERTIFY_OTHER);
        signatureSubpacketGenerator.setPreferredSymmetricAlgorithms(false, PublicKeyAlgorithmTags.DSA)
        signatureSubpacketGenerator.setPreferredHashAlgorithms(false, HashAlgorithmTags.SHA512)
        signatureSubpacketGenerator.setPreferredCompressionAlgorithms(false, CompressionAlgorithmTags.ZIP)

	if err != nil {
		t.Fatalf("Failed to parse certificate: %s", err)
	}
	if cert.PublicKeyAlgorithm != DSA {
		t.Errorf("Parsed key algorithm was not DSA")
	}
	parsedKey, ok := cert.PublicKey.(*dsa.PublicKey)
	if !ok {
		t.Fatalf("Parsed key was not a DSA key: %s", err)
	}
	if expectedKey.Y.Cmp(parsedKey.Y) != 0 ||
		expectedKey.P.Cmp(parsedKey.P) != 0 ||

	stat.Ctim.Sec = int64(statLE.Ctim)
	stat.Ctim.Nsec = 0 //zos doesn't return nanoseconds
	stat.Blksize = int64(statLE.Blksize)
	stat.Blocks = statLE.Blocks
}

func svcCall(fnptr unsafe.Pointer, argv *unsafe.Pointer, dsa *uint64)
func svcLoad(name *byte) unsafe.Pointer
func svcUnload(name *byte, fnptr unsafe.Pointer) int64

func (d *Dirent) NameString() string {
	if d == nil {
		return ""
	}
	s := string(d.Name[:])

	< crypto/rand
	< crypto/internal/mlkem768
	< crypto/ed25519
	< encoding/asn1
	< golang.org/x/crypto/cryptobyte/asn1
	< golang.org/x/crypto/cryptobyte
	< crypto/internal/bigmod
	< crypto/dsa, crypto/elliptic, crypto/rsa
	< crypto/ecdsa
	< CRYPTO-MATH;

	CGO, net !< CRYPTO-MATH;

	# TLS, Prince of Dependencies.
	CRYPTO-MATH, NET, container/list, encoding/hex, encoding/pem

      <match value="-----BEGIN RSA KEY-----" type="string" offset="0"/>
      <match value="-----BEGIN RSA PRIVATE KEY-----" type="string" offset="0"/>
      <match value="-----BEGIN DSA KEY-----" type="string" offset="0"/>
      <match value="-----BEGIN DSA PRIVATE KEY-----" type="string" offset="0"/>
    </magic>
  </mime-type>
  <mime-type type="application/x-x509-key;format=der">
    <sub-class-of type="application/x-x509-key"/>

pkg crypto/dsa, func Verify(*PublicKey, []uint8, *big.Int, *big.Int) bool
pkg crypto/dsa, type ParameterSizes int
pkg crypto/dsa, type Parameters struct
pkg crypto/dsa, type Parameters struct, G *big.Int
pkg crypto/dsa, type Parameters struct, P *big.Int
pkg crypto/dsa, type Parameters struct, Q *big.Int
pkg crypto/dsa, type PrivateKey struct
pkg crypto/dsa, type PrivateKey struct, X *big.Int

	},
	"crypto/des": {
		{"(KeySizeError).Error", Method, 0},
		{"BlockSize", Const, 0},
		{"KeySizeError", Type, 0},
		{"NewCipher", Func, 0},
		{"NewTripleDESCipher", Func, 0},
	},
	"crypto/dsa": {
		{"ErrInvalidPublicKey", Var, 0},
		{"GenerateKey", Func, 0},
		{"GenerateParameters", Func, 0},
		{"L1024N160", Const, 0},
		{"L2048N224", Const, 0},
		{"L2048N256", Const, 0},
		{"L3072N256", Const, 0},

edgestack.me

// DDNS5 : https://ddns5.com
// Submitted by Cameron Elliott <******@****.***>
ddns5.com

// Debian : https://www.debian.org/
// Submitted by Peter Palfrader / Debian Sysadmin Team <dsa******@****.***>
debian.net

// Deno Land Inc : https://deno.com/
// Submitted by Luca Casonato <******@****.***>
deno.dev
deno-staging.dev

// deSEC : https://desec.io/