tasks.withType<Sign>().configureEach { isEnabled = signArtifacts }

signing {
    useInMemoryPgpKeys(pgpSigningKey.orNull, pgpSigningPassPhrase.orNull)
    publishing.publications.configureEach {
        if (signArtifacts) {
            signing.sign(this)
        }
    }

dependencies {
    coreRuntimeOnly(platform(project(":core-platform")))

    agentsRuntimeOnly(project(":instrumentation-agent"))

    pluginsRuntimeOnly(platform(project(":distributions-basics")))

    pluginsRuntimeOnly(project(":signing"))

package jcifs.internal;


/**
 * @author mbechler
 *
 */
public interface SMBSigningDigest {

    /**
     * Performs MAC signing of the SMB. This is done as follows.
     * The signature field of the SMB is overwritten with the sequence number;
     * The MD5 digest of the MAC signing key + the entire SMB is taken;
     * The first 8 bytes of this are placed in the signature field.
     *
     * @param data

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.plugins.signing.type;

import org.gradle.api.tasks.Input;
import org.gradle.plugins.signing.signatory.Signatory;

import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * The type of signature.
 */

// tag::all[]
// tag::use-plugin[]
plugins {
// end::use-plugin[]
    `java-library`
    `maven-publish`
// tag::use-plugin[]
    signing
}
// end::use-plugin[]

group = "com.example"
version = "1.0"

// tag::defining-sources-jar-task[]
java {
    withJavadocJar()
    withSourcesJar()
}
// end::defining-sources-jar-task[]

// tag::pom-customization[]
// tag::versions-resolved[]
publishing {

import org.bouncycastle.openpgp.operator.bc.BcPGPContentSignerBuilder
import org.bouncycastle.openpgp.operator.bc.BcPGPDigestCalculatorProvider
import org.gradle.plugins.signing.signatory.pgp.PgpSignatoryFactory
import org.gradle.plugins.signing.type.pgp.ArmoredSignatureType

@CompileStatic
@Canonical
class SimpleKeyRing {
    final String name
    final PGPSecretKey secretKey
    final PGPPublicKey publicKey

// template.
type SigningPolicy interface {
	// not-exporting apply forces signing policy implementations to be internal
	// to this package.
	apply(template *x509.Certificate, signerNotAfter time.Time) error
}

// PermissiveSigningPolicy is the signing policy historically used by the local
// signer.
//
//   - It forwards all SANs from the original signing request.
//   - It sets allowed usages as configured in the policy.

apiVersion: release-notes/v2
kind: security-fix
area: security
issue:
  - 27238
releaseNotes:
  - |

 * limitations under the License.
 */
package org.gradle.plugins.signing;

import com.google.common.base.Function;
import groovy.lang.Closure;
import org.gradle.api.artifacts.PublishArtifact;
import org.gradle.api.file.FileCollection;
import org.gradle.plugins.signing.signatory.Signatory;
import org.gradle.plugins.signing.type.SignatureType;
import org.gradle.util.internal.ConfigureUtil;

import java.io.File;

		t.Errorf("Failed to parse cert (error: %s)", err)
	}

	if !signingCertFromSecret.Equal(signingCert) {
		t.Error("CA signing cert does not match the K8s secret")
	}
}

func TestCreateSelfSignedIstioCAWithSecret(t *testing.T) {
	rootCertPem := cert1Pem
	// Use the same signing cert and root cert for self-signed CA.
	signingCertPem := []byte(cert1Pem)
	signingKeyPem := []byte(key1Pem)