xmldsig

type AlgorithmMethod struct {
	Algorithm string `xml:"Algorithm,attr"`
	XPath     string `xml:"ds:XPath,omitempty"`
}

type Cert struct {
	CertDigest   *CertDigest   `xml:"xades:CertDigest"`
	IssuerSerial *IssuerSerial `xml:"xades:IssuerSerial"`
}

type CertDigest struct {
	DigestMethod *AlgorithmMethod `xml:"ds:DigestMethod"`
	DigestValue  string           `xml:"ds:DigestValue"`
}

type Certificate struct {
	CaChain []*x509.Certificate
	// contains filtered or unexported fields
}

type ClaimedRoles struct {
	ClaimedRole []string `xml:"xades:ClaimedRole"`
}

type DataObjectFormat struct {
	ObjectReference  string            `xml:"ObjectReference,attr"`
	Description      string            `xml:"xades:Description,omitempty"`
	ObjectIdentifier *ObjectIdentifier `xml:"xades:ObjectIdentifier,omitempty"`
	MimeType         string            `xml:"xades:MimeType,omitempty"`
	Encoding         string            `xml:"xades:Encoding,omitempty"`
}

type ECKeyValue struct {
	XMLName xml.Name `xml:"dsig11:ECKeyValue"`

	NamedCurve NamedCurve `xml:"dsig11:NamedCurve"`
	PublicKey  string     `xml:"dsig11:PublicKey"`
}

type Identifier struct {
	Qualifier string `xml:"Qualifier,attr,omitempty"`
	Value     string `xml:",chardata"`
}

type IssuerSerial struct {
	X509IssuerName   string `xml:"ds:X509IssuerName"`
	X509SerialNumber string `xml:"ds:X509SerialNumber"`
}

type KeyAlgorithm string

type KeyInfo struct {
	XMLName xml.Name `xml:"ds:KeyInfo"`
	ID      string   `xml:"Id,attr"`

	DSig11Namespace string `xml:"xmlns:dsig11,attr,omitempty"`

	X509Data *X509Data `xml:"ds:X509Data,omitempty"`
	KeyValue *KeyValue `xml:"ds:KeyValue,omitempty"` // optional, some APIs require it
}

type KeyValue struct {
	// RSA (XMLDSIG 1.0)
	RSA *RSAKeyValue `xml:"ds:RSAKeyValue,omitempty"`

	// EC (XMLDSIG 1.1)
	EC *ECKeyValue `xml:"dsig11:ECKeyValue,omitempty"`
}

type NamedCurve struct {
	URI string `xml:"URI,attr"`
}

type Namespaces map[string]string

type Object struct {
	QualifyingProperties *QualifyingProperties `xml:"xades:QualifyingProperties"`
}

type ObjectIdentifier struct {
	Identifier  Identifier `xml:"xades:Identifier"`
	Description string     `xml:"xades:Description,omitempty"`
}

type Option func(o *options) error

type PolicyIdentifier struct {
	SignaturePolicyID *PolicySignaturePolicyID `xml:"xades:SignaturePolicyId"`
}

type PolicySigPolicyHash struct {
	DigestMethod *AlgorithmMethod `xml:"ds:DigestMethod,omitempty"`
	DigestValue  string           `xml:"ds:DigestValue,omitempty"`
}

type PolicySigPolicyID struct {
	Identifier  Identifier `xml:"xades:Identifier"`
	Description string     `xml:"xades:Description,omitempty"`
}

type PolicySignaturePolicyID struct {
	SigPolicyID         PolicySigPolicyID    `xml:"xades:SigPolicyId"`
	SigPolicyHash       *PolicySigPolicyHash `xml:"xades:SigPolicyHash,omitempty"`
	SigPolicyQualifiers *SigPolicyQualifiers `xml:"xades:SigPolicyQualifiers,omitempty"`
}

type PrivateKeyInfo struct {
	Algorithm KeyAlgorithm

	// RSA fields
	Modulus  string
	Exponent string

	// ECDSA fields
	CurveURI  string
	PublicKey string
}

type QualifyingProperties struct {
	XAdESNamespace string `xml:"xmlns:xades,attr,omitempty"`
	ID             string `xml:"Id,attr"`
	Target         string `xml:"Target,attr"`

	SignedProperties   *SignedProperties   `xml:"xades:SignedProperties"`
	UnsignedProperties *UnsignedProperties `xml:"xades:UnsignedProperties,omitempty"`
}

type RSAKeyValue struct {
	XMLName xml.Name `xml:"ds:RSAKeyValue"`

	Modulus  string `xml:"ds:Modulus,omitempty"`
	Exponent string `xml:"ds:Exponent,omitempty"`
}

type Reference struct {
	ID   string `xml:"Id,attr,omitempty"`
	Type string `xml:"Type,attr,omitempty"`
	URI  string `xml:"URI,attr"`

	Transforms   *Transforms      `xml:"ds:Transforms,omitempty"`
	DigestMethod *AlgorithmMethod `xml:"ds:DigestMethod"`
	DigestValue  string           `xml:"ds:DigestValue"`
}

type SigPolicyQualifier struct {
	SPURI string `xml:"xades:SPURI"`
}

type SigPolicyQualifiers struct {
	SigPolicyQualifier []SigPolicyQualifier `xml:"xades:SigPolicyQualifier"`
}

type Signature struct {
	DSigNamespace string   `xml:"xmlns:ds,attr,omitempty"`
	ID            string   `xml:"Id,attr"`
	XMLName       xml.Name `xml:"ds:Signature"`

	SignedInfo *SignedInfo `xml:"ds:SignedInfo"`
	Value      *Value      `xml:"ds:SignatureValue"`
	KeyInfo    *KeyInfo    `xml:"ds:KeyInfo"`
	Object     *Object     `xml:"ds:Object,omitempty"`
	// contains filtered or unexported fields
}

type SignedDataObjectProperties struct {
	DataObjectFormat *DataObjectFormat `xml:"xades:DataObjectFormat"`
}

type SignedInfo struct {
	XMLName xml.Name `xml:"ds:SignedInfo"`
	ID      string   `xml:"Id,attr,omitempty"`

	CanonicalizationMethod *AlgorithmMethod `xml:"ds:CanonicalizationMethod"`
	SignatureMethod        *AlgorithmMethod `xml:"ds:SignatureMethod"`
	Reference              []*Reference     `xml:"ds:Reference"`
}

type SignedProperties struct {
	XMLName                    xml.Name                    `xml:"xades:SignedProperties"`
	ID                         string                      `xml:"Id,attr"`
	SignedSignatureProperties  *SignedSignatureProperties  `xml:"xades:SignedSignatureProperties"`
	SignedDataObjectProperties *SignedDataObjectProperties `xml:"xades:SignedDataObjectProperties,omitempty"`
}

type SignedSignatureProperties struct {
	SigningTime               string              `xml:"xades:SigningTime"`
	SigningCertificate        *SigningCertificate `xml:"xades:SigningCertificate"`
	SignaturePolicyIdentifier *PolicyIdentifier   `xml:"xades:SignaturePolicyIdentifier,omitempty"`
	SignerRole                *SignerRole         `xml:"xades:SignerRole,omitempty"`
}

type SignerRole struct {
	ClaimedRoles *ClaimedRoles `xml:"xades:ClaimedRoles"`
}

type SigningCertificate struct {
	Cert []*Cert `xml:"xades:Cert"`
}

type Timestamp struct {
	CanonicalizationMethod *AlgorithmMethod `xml:"ds:CanonicalizationMethod"`
	EncapsulatedTimeStamp  string           `xml:"xades:EncapsulatedTimeStamp"`
}

type TimestampSignatureValue struct {
	XMLName   xml.Name
	Namespace string `xml:"xmlns:ds,attr"`
	ID        string `xml:"Id,attr"`
	Value     string `xml:",chardata"`
}

type Transforms struct {
	Transform []*AlgorithmMethod `xml:"ds:Transform"`
}

type UnsignedProperties struct {
	SignatureTimestamp *Timestamp `xml:"xades:UnsignedSignatureProperties>xades:SignatureTimestamp"`
}

type Value struct {
	ID    string `xml:"Id,attr,omitempty"`
	Value string `xml:",chardata"`
}

type X509Data struct {
	X509Certificate []string `xml:"ds:X509Certificate"`
}

type XAdESConfig struct {
	// Configuration for XAdES always present fields
	TimestampFormatter            func(time.Time) string
	IssuerSerializer              func(pkix.RDNSequence) string
	SigningCertificateHash        crypto.Hash
	SignedPropertiesCanonicalizer dsig.Canonicalizer
	SignedPropertiesHash          crypto.Hash

	// XAdES-specific optional XML fields
	Role             XAdESSignerRole
	Description      string
	DataObjectFormat *DataObjectFormat
	Policy           *XAdESPolicyConfig
	IncludeCaChain   bool

	// When true, digests in XAdES elements are hex-encoded
	// before base64: base64(hex(hash)) instead of base64(hash).
	HexEncodeDigests bool
	// When true, the signing certificate digest is computed
	// over the base64 PEM text instead of the raw DER bytes.
	HashPEMText bool
	// SignedPropertiesSerializer, when set, produces the exact bytes of
	// <xades:SignedProperties> that are hashed, replacing the default
	// canonicalization.
	SignedPropertiesSerializer func([]byte) ([]byte, error)
}

type XAdESPolicyConfig struct {
	URL         string `json:"url"`                   // URL to the policy definition; also used as SPURI qualifier when Identifier is set
	Identifier  string `json:"identifier,omitempty"`  // OID/URN identifier (when set, used as the policy identifier instead of URL)
	Description string `json:"description,omitempty"` // Optional human description
	Algorithm   string `json:"algorithm"`             // eg. SHA1 or SHA256
	Hash        string `json:"hash"`                  // Base64 encoded hash (usually provided with policy)
}

type XAdESSignerRole string

type XMLDSigConfig struct {
	DataCanonicalizer            dsig.Canonicalizer
	DataHash                     crypto.Hash
	IncludeKeyValue              bool
	ReferenceKeyInfoInSignedInfo bool
	KeyInfoHash                  crypto.Hash
	KeyInfoCanonicalizer         dsig.Canonicalizer
	SignedInfoCanonicalizer      dsig.Canonicalizer
	SignedInfoHash               crypto.Hash
	// ECDSAFormatDER returns ECDSA signatures as raw DER (ZATCA) instead of the W3C-standard r||s form.
	ECDSAFormatDER                    bool
	OmitDocumentReferenceType         bool
	OmitDataCanonicalizationTransform bool
	DocumentTransforms                []*AlgorithmMethod
	PreHashTransforms                 func([]byte) ([]byte, error)
}