// only be the result of a scalar multiplication if one of the inputs is the
	// zero scalar or the point at infinity.

	if boring.Enabled {
		return boring.ECDH(local.boring, remote.boring)
	}

	boring.Unreachable()
	p, err := c.newPoint().SetBytes(remote.publicKey)
	if err != nil {
		return nil, err
	}
	if _, err := p.ScalarMult(p, local.privateKey); err != nil {

// Unix cryptographically secure pseudorandom number
// generator.

package rand

import (
	"crypto/internal/boring"
	"errors"
	"io"
	"os"
	"sync"
	"sync/atomic"
	"syscall"
	"time"
)

const urandomDevice = "/dev/urandom"

func init() {
	if boring.Enabled {
		Reader = boring.RandReader
		return
	}
	Reader = &reader{}
}

// A reader satisfies reads by reading from urandomDevice

	c uint8
}

var (
	typSize uint64

	typA, typB, typC uint64
)

func main() {
	if smallInt != smallIntAsm {
		println("smallInt", smallInt, "!=", smallIntAsm)
	}
	if bigInt != bigIntAsm {
		println("bigInt", uint64(bigInt), "!=", bigIntAsm)
	}
	if stringVal != string(stringAsm[:]) {
		println("stringVal", stringVal, "!=", string(stringAsm[:]))
	}
	if longStringVal != string(longStringAsm[:]) {

// license that can be found in the LICENSE file.

//go:build !boringcrypto

package rsa

import "crypto/internal/boring"

func boringPublicKey(*PublicKey) (*boring.PublicKeyRSA, error) {
	panic("boringcrypto: not available")
}
func boringPrivateKey(*PrivateKey) (*boring.PrivateKeyRSA, error) {
	panic("boringcrypto: not available")

// state of the hash.
func New() hash.Hash {
	if boring.Enabled {
		return boring.NewSHA256()
	}
	d := new(digest)
	d.Reset()
	return d
}

// New224 returns a new hash.Hash computing the SHA224 checksum.
func New224() hash.Hash {
	if boring.Enabled {
		return boring.NewSHA224()
	}
	d := new(digest)
	d.is224 = true
	d.Reset()
	return d
}

//go:build boringcrypto

package boring_test

import (
	"crypto/boring"
	"runtime"
	"testing"
)

func TestEnabled(t *testing.T) {
	supportedPlatform := runtime.GOOS == "linux" && (runtime.GOARCH == "amd64" || runtime.GOARCH == "arm64")
	if supportedPlatform && !boring.Enabled() {
		t.Error("Enabled returned false on a supported platform")
	} else if !supportedPlatform && boring.Enabled() {

		return nil, err
	}
	k := pub.Size()
	if len(msg) > k-11 {
		return nil, ErrMessageTooLong
	}

	if boring.Enabled && random == boring.RandReader {
		bkey, err := boringPublicKey(pub)
		if err != nil {
			return nil, err
		}
		return boring.EncryptRSAPKCS1(bkey, msg)
	}
	boring.UnreachableExceptTests()

	// EM = 0x00 || 0x02 || PS || 0x00 || M
	em := make([]byte, k)
	em[1] = 2

		"Abs": func(v, x bigInt) bool {
			return checkAliasingOneArg(t, (*big.Int).Abs, v.Int, x.Int)
		},
		"Add": func(v, x, y bigInt) bool {
			return checkAliasingTwoArgs(t, (*big.Int).Add, v.Int, x.Int, y.Int)
		},
		"And": func(v, x, y bigInt) bool {
			return checkAliasingTwoArgs(t, (*big.Int).And, v.Int, x.Int, y.Int)
		},
		"AndNot": func(v, x, y bigInt) bool {

	// well-specified number of random bytes is included in the signature, in a
	// well-specified way.

	if boring.Enabled && rand == boring.RandReader {
		bkey, err := boringPrivateKey(priv)
		if err != nil {
			return nil, err
		}
		return boring.SignRSAPSS(bkey, hash, digest, opts.saltLength())
	}
	boring.UnreachableExceptTests()

	if opts != nil && opts.Hash != 0 {
		hash = opts.Hash
	}

	NET, log
	< net/mail;

	NONE < crypto/internal/boring/sig, crypto/internal/boring/syso;
	sync/atomic < crypto/internal/boring/bcache, crypto/internal/boring/fipstls;
	crypto/internal/boring/sig, crypto/internal/boring/fipstls < crypto/tls/fipsonly;

	# CRYPTO is core crypto algorithms - no cgo, fmt, net.
	crypto/internal/boring/sig,
	crypto/internal/boring/syso,
	golang.org/x/sys/cpu,
	hash, embed
	< crypto