What changed in Go, Rust and Solidity this week.

// This program demonstrates the deprecation warning for RSA PKCS#1 v1.5 encryption.
// It uses the standard library only and runs in Go 1.27.1.
// The EncryptPKCS1v15 function still exists but is marked Deprecated.
// The compiler will emit a warning when this function is called.

package main

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

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

	// Message to encrypt; must be shorter than the modulus minus 11 bytes.
	msg := []byte("Hello, RSA PKCS#1 v1.5")

	// Call the deprecated EncryptPKCS1v15 function.
	ciphertext, err := rsa.EncryptPKCS1v15(rand.Reader, &priv.PublicKey, msg)
	if err != nil {
		panic(err)
	}

	// Decrypt the ciphertext using the deprecated DecryptPKCS1v15 function.
	plain, err := rsa.DecryptPKCS1v15(rand.Reader, priv, ciphertext)
	if err != nil {
		panic(err)
	}

	fmt.Printf("Original: %s\nDecrypted: %s\n", msg, plain)
}

// This program demonstrates that the removed GODEBUG flags no longer work.
// In Go 1.27, setting them has no effect.  The program simply prints a message.
package main

import (
	"fmt"
	"os"
)

func main() {
	// Attempt to set a removed GODEBUG flag.
	os.Setenv("GODEBUG", "tlsunsafeekm=1")
	// In Go 1.27, this flag is ignored.
	fmt.Println("GODEBUG flags are now removed in Go 1.27; setting them has no effect.")
}

// This program demonstrates the new bytes.Buffer.Peek method.
// It is written for Go 1.27.1, where Peek is already available.
package main

import (
	"bytes"
	"fmt"
)

func main() {
	// Create a buffer with some data.
	var buf bytes.Buffer
	buf.WriteString("Hello, world!")

	// Peek at the first 5 bytes without consuming them.
	p, err := buf.Peek(5)
	if err != nil {
		fmt.Println("Peek error:", err)
		return
	}
	fmt.Println("Peeked bytes:", string(p)) // prints "Hello"

	// The buffer is still at the start; reading now returns the same data.
	b, _ := buf.ReadString(',')
	fmt.Println("Read after peek:", b) // prints "Hello,"
}

// This program demonstrates the effect of the v4.0.0 change to
// actions/upload-pages-artifact: dotfiles are not included in the
// artifact by default.  Since we cannot run the GitHub action here,
// we simulate the behavior by creating a temporary directory with
// a normal file and a dotfile, then listing the files that would
// be uploaded.

use std::fs::{self, File};
use std::io::Write;
use std::path::Path;

fn main() -> std::io::Result<()> {
    // Create a temporary directory
    let dir = std::env::temp_dir().join("artifact_demo");
    if dir.exists() {
        fs::remove_dir_all(&dir)?;
    }
    fs::create_dir(&dir)?;

    // Normal file
    let normal_path = dir.join("index.html");
    File::create(&normal_path)?.write_all(b"<html></html>")?;

    // Dotfile
    let dot_path = dir.join(".gitignore");
    File::create(&dot_path)?.write_all(b"*")?;

    // Simulate the artifact upload: list non-dot files
    println!("Files that would be uploaded by v4.0.0:");
    for entry in fs::read_dir(&dir)? {
        let entry = entry?;
        let file_name = entry.file_name();
        let name_str = file_name.to_string_lossy();
        if !name_str.starts_with('.') {
            println!("  {}", name_str);
        }
    }

    // Clean up
    fs::remove_dir_all(&dir)?;
    Ok(())
}

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