What changed in Go, Rust and Solidity this week.

// This program demonstrates the current limitation of rsa.EncryptOAEP in Go 1.27.1:
// it requires the same hash function for both OAEP and MGF1. The new
// EncryptOAEPWithOptions function, which would allow independent hash
// selection, is not yet available. The code below uses the standard
// EncryptOAEP with a single hash function (sha256) for both roles.

package main

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

func main() {
	// Generate a temporary RSA key pair for demonstration.
	priv, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		panic(err)
	}

	// The message to encrypt (e.g., a 256‑bit AES key).
	msg := []byte("example 256‑bit AES key for demonstration")

	// Encrypt using RSA-OAEP with SHA‑256 for both OAEP and MGF1.
	ciphertext, err := rsa.EncryptOAEP(sha256.New(), rand.Reader, &priv.PublicKey, msg, nil)
	if err != nil {
		panic(err)
	}

	// Decrypt to verify correctness.
	plain, err := rsa.DecryptOAEP(sha256.New(), rand.Reader, priv, ciphertext, nil)
	if err != nil {
		panic(err)
	}

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

// This program demonstrates that the crates.io Security tab feature is not yet part of Rust 1.98.1 (edition 2024).
// It simply prints a message explaining the current state.
fn main() {
    println!("The crates.io Security tab is a planned feature; it is not available in the current Rust release.");
}

// This program demonstrates that we can build a static binary for
// a musl target.  It simply prints a message.  The musl version
// used is 1.2.5, which is bundled with the Rust toolchain for
// the x86_64-unknown-linux-musl target.  No external crates are
// required, and the program compiles and runs in under a second.

fn main() {
    // Print a simple message to show the binary works.
    println!("Hello from a musl‑linked Rust binary!");
}

// This program simply prints a message about the new Rust contributor sponsorship page.
// It demonstrates that the change is a web‑based feature, not a language feature.
fn main() {
    println!("Rust now has a dedicated Funding page listing contributors open to sponsorship.");
}

// 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");
    }
}