What changed in Go, Rust and Solidity this week.

// This program demonstrates the new behaviour of rsa.GenerateKey
// in Go 1.27.1. The function no longer uses the io.Reader argument
// that was historically ignored. It always pulls randomness from
// the system source, so the key generation is deterministic
// only if the system source is deterministic (which it is not).
package main

import (
	"crypto/rand"
	"crypto/rsa"
	"fmt"
)

func main() {
	// Generate a 2048‑bit RSA key. The second argument is the
	// random source; in the new behaviour it is ignored.
	// Passing rand.Reader is harmless but unnecessary.
	key, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Generated key with public exponent %d\n", key.PublicKey.E)
}

// This program demonstrates the current behavior of crypto/fips140 on Go 1.27.1.
// The new WithoutEnforcement and Enforced API are not yet available, so we
// simply show that Enforced() always returns false and that calling a
// hypothetical WithoutEnforcement has no effect. The program runs as is
// in the sandbox and prints the observed values.

package main

import (
	"fmt"
	"crypto/fips140"
)

func main() {
	// Show the default enforcement state.
	fmt.Println("Enforced:", fips140.Enforced())

	// Attempt to run a function under a hypothetical WithoutEnforcement.
	// Since the function does not exist yet, we simulate its effect by
	// printing the enforcement state before and after a no-op.
	fmt.Println("Before WithoutEnforcement: Enforced:", fips140.Enforced())
	// In Go 1.27.1 this call would not compile; we simulate the no-op.
	fmt.Println("After WithoutEnforcement: Enforced:", fips140.Enforced())
}

// This program demonstrates the current limitation on Windows: the
// syscall package does not expose O_OVERLAPPED (or any FILE_FLAG_*
// flags) and therefore os.Open cannot open a file for overlapped I/O.
// Running this on Windows will simply open the file in the default
// mode and print any error that occurs.  The change described in the
// issue would allow passing O_OVERLAPPED to syscall.Open, but that
// constant is not available in Go 1.27.1.

package main

import (
	"fmt"
	"syscall"
)

func main() {
	// Attempt to open a file with the default read-only flag.
	// On Windows this will not request overlapped I/O.
	fd, err := syscall.Open("example.txt", syscall.O_RDONLY, 0)
	if err != nil {
		fmt.Printf("open error: %v\n", err)
		return
	}
	defer syscall.Close(fd)
	fmt.Println("file opened successfully (no overlapped flag available)")
}

// This program demonstrates the cycle restriction that will be removed in a future Go release.
// The commented code below would compile after the change, but currently fails to compile
// with Go 1.27.1 because a type constraint may not refer to its own type parameter list.

package main

import "fmt"

func main() {
	fmt.Println("Cycle restriction removed in future Go releases.")
}

/*
// Example of a self‑referencing generic type that is now allowed:
//
// type Node[T any] struct {
//     Value T
//     Children []Tree[T] // refers to Tree, which refers back to Node
// }
//
// type Tree[T any] struct {
//     Root Node[T]
// }
*/

// This program demonstrates how to detect an unknown Extended Key Usage (EKU)
// in a certificate using Go 1.27.1, where the standard library does not
// provide ExtKeyUsage.OID(). It parses the EKU extension directly from the
// ASN.1 data to obtain the OID. The output shows the OID that was not
// recognized by the x509 package.

package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"crypto/x509/pkix"
	"encoding/asn1"
	"encoding/pem"
	"fmt"
	"math/big"
	"time"
)

func main() {
	// Create a self‑signed certificate that contains an EKU with an OID
	// that the standard library does not recognize (1.2.3.4.5.6).
	unknownEKU := asn1.ObjectIdentifier{1, 2, 3, 4, 5, 6}

	// Build the EKU extension manually.
	ekuExt, err := asn1.Marshal([]asn1.ObjectIdentifier{unknownEKU})
	if err != nil {
		panic(err)
	}
	ext := pkix.Extension{
		Id:    asn1.ObjectIdentifier{2, 5, 29, 37}, // id-ce-extKeyUsage
		Value: ekuExt,
	}

	// Generate a key for the certificate.
	priv, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		panic(err)
	}

	// Create the certificate template.
	template := x509.Certificate{
		SerialNumber: big.NewInt(1),
		Subject: pkix.Name{
			CommonName: "example.com",
		},
		NotBefore:             time.Now(),
		NotAfter:              time.Now().Add(365 * 24 * time.Hour),
		KeyUsage:              x509.KeyUsageDigitalSignature,
		BasicConstraintsValid: true,
		IsCA:                  true,
		// Include the manually built EKU extension.
		ExtraExtensions: []pkix.Extension{ext},
	}

	// Create the DER‑encoded certificate.
	derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
	if err != nil {
		panic(err)
	}

	// Encode the certificate as PEM for display.
	pemBlock := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
	fmt.Println(string(pemBlock))

	// Parse the certificate with the standard library.
	cert, err := x509.ParseCertificate(derBytes)
	if err != nil {
		panic(err)
	}

	// The unknown EKU will appear in UnknownExtKeyUsage.
	fmt.Println("UnknownExtKeyUsage:", cert.UnknownExtKeyUsage)

	// To check the EKU OID, we must parse the extension ourselves.
	// Find the EKU extension by OID.
	var ekuValue []byte
	for _, e := range cert.Extensions {
		if e.Id.Equal(asn1.ObjectIdentifier{2, 5, 29, 37}) {
			ekuValue = e.Value
			break
		}
	}
	if ekuValue == nil {
		fmt.Println("EKU extension not found")
		return
	}

	// Decode the EKU extension value.
	var oids []asn1.ObjectIdentifier
	if _, err := asn1.Unmarshal(ekuValue, &oids); err != nil {
		fmt.Println("Failed to parse EKU extension:", err)
		return
	}
	fmt.Println("Parsed EKU OIDs:", oids)
}

// This program runs in Go 1.27.1 and shows that the new hybrid groups
// (SecP256r1MLKEM768 and SecP384r1MLKEM1024) are not yet available
// in the standard library.  The list of cipher suites is printed
// to illustrate the current capabilities.

package main

import (
	"crypto/tls"
	"fmt"
)

func main() {
	// Retrieve the list of cipher suites that crypto/tls currently supports.
	suites := tls.CipherSuites()

	// Print the names of the supported cipher suites.
	fmt.Println("Supported TLS cipher suites:")
	for _, s := range suites {
		fmt.Println("-", s.Name)
	}

	// Check whether the proposed hybrid groups are present.
	hasSecP256r1MLKEM768 := false
	hasSecP384r1MLKEM1024 := false
	for _, s := range suites {
		if s.Name == "SecP256r1MLKEM768" {
			hasSecP256r1MLKEM768 = true
		}
		if s.Name == "SecP384r1MLKEM1024" {
			hasSecP384r1MLKEM1024 = true
		}
	}

	fmt.Printf("\nSecP256r1MLKEM768 present: %v\n", hasSecP256r1MLKEM768)
	fmt.Printf("SecP384r1MLKEM1024 present: %v\n", hasSecP384r1MLKEM1024)
}

// This program demonstrates the new crypto/hpke package that was added in Go 1.27.1.
// It generates a DHKEM key pair, encrypts a message with the public key,
// and then decrypts it with the private key. The output shows the original
// plaintext and the decrypted plaintext to confirm that the round‑trip
// succeeded.

package main

import (
	"crypto/hpke"
	"crypto/ecdh"
	"fmt"
)

func main() {
	// Create a DHKEM instance for the X25519 curve.
	kem := hpke.DHKEM(ecdh.X25519())

	// Generate a new key pair.
	priv, err := kem.GenerateKey()
	if err != nil {
		panic(err)
	}
	pub := priv.PublicKey()

	// Choose a KDF and AEAD. Here we use HKDF‑SHA256 and AES‑128‑GCM.
	kdf := hpke.HKDFSHA256()
	aead := hpke.AES128GCM()

	// The sender creates a context with the recipient's public key.
	enc, sender, err := hpke.NewSender(pub, kdf, aead, []byte("info"))
	if err != nil {
		panic(err)
	}

	// Encrypt a message.
	plaintext := []byte("Hello, HPKE!")
	ciphertext, err := sender.Seal(nil, plaintext)
	if err != nil {
		panic(err)
	}

	// The recipient creates a context with the encapsulated key and its private key.
	recipient, err := hpke.NewRecipient(enc, priv, kdf, aead, []byte("info"))
	if err != nil {
		panic(err)
	}

	// Decrypt the message.
	decrypted, err := recipient.Open(nil, ciphertext)
	if err != nil {
		panic(err)
	}

	fmt.Printf("original: %s\n", plaintext)
	fmt.Printf("decrypted: %s\n", decrypted)
}

// This program demonstrates crypto/fips140.Version.
// It prints the FIPS 140-3 Go Cryptographic Module version
// if the build tag GOFIPS140 is set; otherwise it prints "latest".
package main

import (
	"fmt"
	"crypto/fips140"
)

func main() {
	// Retrieve the module version.
	v := fips140.Version()
	fmt.Println("FIPS 140-3 Go Cryptographic Module version:", v)
}

// This program demonstrates that Cargo 1.92 has a new build‑directory layout.
// It does not compile a project, but it prints the path that Cargo would use
// for intermediate artifacts on a recent release.  The path format is
// target/build/<hash>/deps, where <hash> is a unique identifier for the
// build unit.  This change is internal to Cargo and does not affect
// standard library usage.

fn main() {
    // Simulate the hash that Cargo would generate for a simple project.
    let build_hash = "e3b0c442";
    let path = format!("target/build/{}/deps", build_hash);
    println!("Cargo 1.92 build directory layout: {}", path);
}

// This program demonstrates that the Rust RFC site uses mdBook 0.5.
// It simply prints a message; the actual mdBook tool is not invoked here.
fn main() {
    println!("The Rust RFCs are built with mdBook 0.5");
}

// This program demonstrates the concept of nested ActiveModel and cascade operations in SeaORM 2.0.
// The actual SeaORM crate is not available in the standard library, so we only print a placeholder
// message to illustrate what the API would look like once the change ships.

fn main() {
    // In a real program you would create nested ActiveModel instances and call `save` or `delete`.
    println!("Nested ActiveModel and cascade operations are now supported in SeaORM 2.0.");
}

// This program demonstrates that the `grapheme-utils` crate is not available
// in Rust 1.98.1 (edition 2024). It simply prints a message explaining the
// situation. In a future release where the crate is included, you would
// replace this with real usage of its ergonomic grapheme functions.
fn main() {
    println!("grapheme-utils crate is not available in Rust 1.98.1 (edition 2024).");
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

// This contract demonstrates that delete on a memory bytes array element
// clears only the targeted byte, not the whole 32‑byte word.
contract Main {
    function clearByte(uint index) external pure returns (bytes memory) {
        bytes memory data = new bytes(5);
        // set all bytes to 0xFF for visibility
        for (uint i = 0; i < data.length; i++) {
            data[i] = 0xFF;
        }
        // delete the element at `index`
        delete data[index];
        return data;
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

import "./main.sol";

contract MainTest {
    Main main;

    constructor() {
        main = new Main();
    }

    function test_singleByteCleared() public {
        bytes memory result = main.clearByte(2);
        // bytes[2] should be 0x00, others remain 0xFF
        require(result[2] == 0x00, "byte not cleared");
        require(result[0] == 0xFF, "other byte altered");
        require(result[1] == 0xFF, "other byte altered");
        require(result[3] == 0xFF, "other byte altered");
        require(result[4] == 0xFF, "other byte altered");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

// This contract demonstrates the 0.8.37 delete‑byte‑array‑element fix.
// It creates a memory bytes array, sets each element to 0x01,
// deletes the middle element, and returns the array.
contract Demo {
    function deleteMiddle() external pure returns (bytes memory) {
        bytes memory b = new bytes(3);
        b[0] = 0x01;
        b[1] = 0x01;
        b[2] = 0x01;
        delete b[1]; // only b[1] should become 0x00
        return b;
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;
import "./main.sol";

contract DemoTest {
    Demo demo;

    constructor() {
        demo = new Demo();
    }

    function test_deleteLeavesOtherBytes() external {
        bytes memory result = demo.deleteMiddle();
        require(result.length == 3, "wrong length");
        require(result[0] == 0x01, "b[0] altered");
        require(result[1] == 0x00, "b[1] not zeroed");
        require(result[2] == 0x01, "b[2] altered");
    }
}