val extensions: List<Extension>,
) {
  /**
   * Returns the standard name of this certificate's signature algorithm as specified by
   * [Signature.getInstance]. Typical values are like "SHA256WithRSA".
   */
  val signatureAlgorithmName: String
    get() {
      return when (signature.algorithm) {
        ObjectIdentifiers.SHA256_WITH_RSA_ENCRYPTION -> "SHA256WithRSA"

    /**
     * Verifies the signature of this response.
     *
     * @param buffer the buffer containing the signature data
     * @param i the starting index in the buffer
     * @param size the size of the signature data
     * @return whether signature verification is successful
     */
    boolean verifySignature(byte[] buffer, int i, int size);

    /**
     * Checks if signature verification failed.
     *

    @Test
    @DisplayName("Should set and get signature")
    void testSignature() {
        // Given
        byte[] signature = new byte[16];
        new SecureRandom().nextBytes(signature);

        // When
        transformHeader.setSignature(signature);

        // Then
        assertArrayEquals(signature, transformHeader.getSignature());
    }

    @Test

	req.URL.RawQuery = query.Encode()

	// Save signature finally.
	req.URL.RawQuery += "&Signature=" + url.QueryEscape(signature)
	return nil
}

// Sign given request using Signature V2.
func signRequestV2(req *http.Request, accessKey, secretKey string) error {
	signer.SignV2(*req, accessKey, secretKey, false)
	return nil
}

// Sign given request using Signature V4.

 */
package jcifs.smb;

/**
 * Exception thrown when SMB message signature validation fails.
 * Indicates that the integrity of an SMB message could not be verified.
 *
 * @author mbechler
 *
 */
public class SMBSignatureValidationException extends SmbException {

    /**
     * Default constructor for SMB signature validation exception.
     */
    public SMBSignatureValidationException() {
    }

					VersionID: [16]byte{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
					ModTime:   baseTime.Add(30 * time.Minute).UnixNano(),
					Signature: [4]byte{1, 1, 1, 1},
					Type:      ObjectType,
					Flags:     0,
				}},
			},
		},
		// Mismatches Modtime+Signature and older...
		1: {
			versions: []xlMetaV2ShallowVersion{
				{header: xlMetaV2VersionHeader{

 */
package jcifs.pac;

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;

/**
 * Represents a PAC signature structure containing checksum type and data.
 * This class parses and holds signature information from Kerberos PAC data,
 * supporting various checksum algorithms including HMAC-MD5 and HMAC-SHA1 with AES.
 */
public class PacSignature {

    /**

            throw new IllegalArgumentException("Signature field exceeds data buffer size");
        }

        // Use fine-grained locking for better concurrency
        this.signingLock.lock();
        try {
            if (this.closed) {
                throw new IllegalStateException("SigningDigest is closed");
            }

            // zero out signature field

ENV CGO_ENABLED=0

# Install curl and minisign
RUN apk add -U --no-cache ca-certificates && \
    apk add -U --no-cache curl && \
    go install aead.dev/minisign/cmd/minisign@v0.2.1

# Download minio binary and signature files
RUN curl -s -q https://dl.min.io/server/minio/hotfixes/linux-${TARGETARCH}/archive/minio.${RELEASE} -o /go/bin/minio && \

		return
	}
	z.ModTime, bts, err = msgp.ReadInt64Bytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "ModTime")
		return
	}
	bts, err = msgp.ReadExactBytes(bts, (z.Signature)[:])
	if err != nil {
		err = msgp.WrapError(err, "Signature")
		return
	}
	{
		var zb0002 uint8
		zb0002, bts, err = msgp.ReadUint8Bytes(bts)
		if err != nil {
			err = msgp.WrapError(err, "Type")
			return
		}