import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "io"
)
 
func encrypt(key, plaintext []byte) ([]byte, error) {
    block, err := aes.NewCipher(key) // key must be 16/24/32 bytes
    if err != nil {
        return nil, err
    }
    
    aesGCM, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }
    
    // Nonce = unique per encryption (NEVER reuse with same key!)
    nonce := make([]byte, aesGCM.NonceSize()) // 12 bytes
    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
        return nil, err
    }
    
    // Encrypt + authenticate
    // Nonce prepend kar rahe hain ciphertext ke saath
    ciphertext := aesGCM.Seal(nonce, nonce, plaintext, nil)
    return ciphertext, nil
}
 
func decrypt(key, ciphertext []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }
    
    aesGCM, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }
    
    nonceSize := aesGCM.NonceSize()
    nonce, ct := ciphertext[:nonceSize], ciphertext[nonceSize:]
    
    plaintext, err := aesGCM.Open(nil, nonce, ct, nil)
    return plaintext, err
}

// Always use crypto/rand for key generation!
key := make([]byte, 32)  // AES-256
if _, err := rand.Read(key); err != nil {
    panic(err)
}

import "crypto/rsa"
 
// Key generation
privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
publicKey := &privateKey.PublicKey
 
// Encryption (OAEP recommended)
ciphertext, err := rsa.EncryptOAEP(
    sha256.New(), rand.Reader, publicKey, plaintext, nil,
)
 
// Decryption
plaintext, err := rsa.DecryptOAEP(
    sha256.New(), rand.Reader, privateKey, ciphertext, nil,
)
 
// Signing (PSS recommended)
hash := sha256.Sum256(message)
signature, err := rsa.SignPSS(
    rand.Reader, privateKey, crypto.SHA256, hash[:], nil,
)
 
// Verification
err = rsa.VerifyPSS(publicKey, crypto.SHA256, hash[:], signature, nil)

import (
    "crypto/ecdsa"
    "crypto/elliptic"
)
 
// Key generation
privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
publicKey := &privateKey.PublicKey
 
// Signing
hash := sha256.Sum256(message)
signature, err := ecdsa.SignASN1(rand.Reader, privateKey, hash[:])
 
// Verification
valid := ecdsa.VerifyASN1(publicKey, hash[:], signature)

import "crypto/ed25519"
 
// Key generation
publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
 
// Signing (no hashing needed — built in!)
signature := ed25519.Sign(privateKey, message)
 
// Verification
valid := ed25519.Verify(publicKey, message, signature)

import "crypto/ecdh"
 
// Both parties:
curve := ecdh.P256()
 
// Alice
alicePriv, _ := curve.GenerateKey(rand.Reader)
alicePub := alicePriv.PublicKey()
 
// Bob
bobPriv, _ := curve.GenerateKey(rand.Reader)
bobPub := bobPriv.PublicKey()
 
// Shared secret (same on both sides!)
aliceSecret, _ := alicePriv.ECDH(bobPub)
bobSecret, _ := bobPriv.ECDH(alicePub)
// aliceSecret == bobSecret ✓

import (
    "crypto/sha256"
    "crypto/sha512"
    "crypto/sha3"
    "crypto/md5"
)
 
// SHA-256 (most common)
hash := sha256.Sum256(data)
fmt.Printf("%x\n", hash)
 
// SHA-256 streaming (large files)
h := sha256.New()
h.Write(chunk1)
h.Write(chunk2)
sum := h.Sum(nil)
 
// SHA-512
hash512 := sha512.Sum512(data)
 
// SHA-3 (Keccak)
hash3 := sha3.Sum256(data)
 
// MD5 (BROKEN! Only for checksums, NEVER for security)
hashMD5 := md5.Sum(data)

import "crypto/hmac"
 
// Create HMAC
mac := hmac.New(sha256.New, secretKey)
mac.Write(message)
tag := mac.Sum(nil)
 
// Verify HMAC (constant-time comparison!)
mac2 := hmac.New(sha256.New, secretKey)
mac2.Write(message)
expectedTag := mac2.Sum(nil)
valid := hmac.Equal(tag, expectedTag)  // timing-safe!

import "crypto/hkdf"
 
// Extract + Expand
reader := hkdf.New(sha256.New, sharedSecret, salt, info)
derivedKey := make([]byte, 32)
io.ReadFull(reader, derivedKey)

import "crypto/pbkdf2"
 
// Derive key from password
key := pbkdf2.Key(
    []byte("password"),
    salt,        // random salt
    100000,      // iterations (higher = slower = safer)
    32,          // key length
    sha256.New,
)

import "golang.org/x/crypto/argon2"
 
// Argon2id (recommended)
hash := argon2.IDKey(
    []byte("password"),
    salt,
    1,         // time cost
    64*1024,   // memory cost (64 MB)
    4,         // parallelism
    32,        // key length
)

import "crypto/hpke"
 
// Receiver generates keypair
suite := hpke.Suite{
    KEM:  hpke.KEM_P256_HKDF_SHA256,
    KDF:  hpke.KDF_HKDF_SHA256,
    AEAD: hpke.AEAD_AES_128_GCM,
}
 
// Sender encrypts
enc, sealer, err := suite.NewSender(recipientPubKey, info)
ciphertext, err := sealer.Seal(plaintext, aad)
 
// Receiver decrypts
opener, err := suite.NewReceiver(recipientPrivKey, enc, info)
plaintext, err := opener.Open(ciphertext, aad)

import "crypto/fips140"
 
// Check if FIPS mode is enabled
if fips140.Enabled() {
    // Only FIPS-approved algorithms used
}
 
// Bypass FIPS enforcement temporarily
fips140.Do(func() {
    // FIPS enforcement suspended in this block
    // Use for legacy code integration
})

import "crypto/rand"
 
// Random bytes
b := make([]byte, 32)
rand.Read(b)
 
// Random integer
n, err := rand.Int(rand.Reader, big.NewInt(100))
// n is in [0, 100)
 
// Random prime
prime, err := rand.Prime(rand.Reader, 256)

import "crypto/subtle"
 
// Constant-time comparison (prevents timing attacks)
result := subtle.ConstantTimeCompare(a, b) // 1 if equal, 0 if not
 
// Constant-time select
val := subtle.ConstantTimeSelect(condition, a, b) // if condition==1: a, else: b
 
// Byte-level equality
result := subtle.ConstantTimeByteEq(x, y) // 1 if equal, 0 if not
 
// Constant-time copy
subtle.ConstantTimeCopy(condition, dst, src) // copy only if condition==1

import "crypto/tls"
 
// TLS server
cert, _ := tls.LoadX509KeyPair("cert.pem", "key.pem")
config := &tls.Config{
    Certificates: []tls.Certificate{cert},
    MinVersion:   tls.VersionTLS12,
}
listener, _ := tls.Listen("tcp", ":443", config)
 
// TLS client
config := &tls.Config{
    MinVersion: tls.VersionTLS12,
}
conn, _ := tls.Dial("tcp", "example.com:443", config)

import "crypto/x509"
 
// Parse PEM certificate
block, _ := pem.Decode(pemData)
cert, err := x509.ParseCertificate(block.Bytes)
 
// Verify certificate chain
roots := x509.NewCertPool()
roots.AppendCertsFromPEM(rootCAPEM)
opts := x509.VerifyOptions{Roots: roots}
chains, err := cert.Verify(opts)
 
// Create self-signed certificate (testing only!)
template := &x509.Certificate{
    SerialNumber: big.NewInt(1),
    Subject:      pkix.Name{Organization: []string{"Test"}},
    NotBefore:    time.Now(),
    NotAfter:     time.Now().Add(365 * 24 * time.Hour),
    KeyUsage:     x509.KeyUsageDigitalSignature,
}
certDER, err := x509.CreateCertificate(
    rand.Reader, template, template, &privKey.PublicKey, privKey,
)