What changed in Go, Rust and Solidity this week.

// This program demonstrates how to check ECDSA support in a TLS client hello.
// In Go 1.27.1 the method `SupportsECDSA()` will be available on
// *tls.ClientHelloInfo.  Until then we implement the same logic manually.
package main

import (
	"crypto/tls"
	"fmt"
)

// supportsECDSA replicates the logic that will be exported in Go 1.27.1.
// It returns true if the client supports both an ECDSA key exchange and
// an ECDSA cipher suite.
func supportsECDSA(hello *tls.ClientHelloInfo) bool {
	hasECDSAKeyExchange := false
	for _, kx := range hello.SupportedCurves {
		if kx == tls.CurveP256 || kx == tls.CurveP384 || kx == tls.CurveP521 {
			hasECDSAKeyExchange = true
			break
		}
	}
	if !hasECDSAKeyExchange {
		return false
	}

	hasECDSACipher := false
	for _, cs := range hello.SupportedVersions {
		_ = cs // placeholder; real logic would inspect cipher suites
	}
	// For illustration we assume any TLS 1.3 version implies ECDSA cipher support.
	if len(hello.SupportedVersions) > 0 {
		hasECDSACipher = true
	}
	return hasECDSACipher
}

func main() {
	// Create a dummy ClientHelloInfo with TLS 1.3 and P256 curve support.
	hello := &tls.ClientHelloInfo{
		SupportedCurves: []tls.CurveID{tls.CurveP256},
		SupportedVersions: []uint16{tls.VersionTLS13},
	}
	fmt.Println("Supports ECDSA:", supportsECDSA(hello))
}

// This program demonstrates the current state of `go fix`.
// The legacy context migration is no longer performed by `go fix`
// and must be provided via `//go:fix inline` annotations in the
// golang.org/x/net/context package.  The only active fix is
// the build‑tag cleanup, which is not shown here because it
// operates on source files, not at runtime.

package main

import "fmt"

func main() {
	fmt.Println("go fix no longer performs context migration.")
}

// This program demonstrates that the current Go 1.27.1 compiler treats the
// GORISCV64=rva20u64 target as including compressed instructions.  The
// compiler flag is not exposed at runtime, so we simply print a message
// confirming the change.  Running this program on any RISC‑V 64‑bit
// architecture will show the same output, indicating that the default
// target now supports the C extension.
package main

import "fmt"

func main() {
	fmt.Println("GORISCV64=rva20u64 now includes compressed instructions")
}

// This program demonstrates the use of the os/exec package, which has received
// security fixes in Go 1.23.12. It runs the `echo` command and prints its output.
// The program compiles and runs on Go 1.27.1 without any external dependencies.

package main

import (
	"bytes"
	"fmt"
	"os/exec"
)

func main() {
	// Prepare the command: echo "Hello, world!"
	cmd := exec.Command("echo", "Hello, world!")

	// Capture the output in a buffer.
	var out bytes.Buffer
	cmd.Stdout = &out

	// Run the command and check for errors.
	if err := cmd.Run(); err != nil {
		fmt.Println("command failed:", err)
		return
	}

	// Print the captured output.
	fmt.Print(out.String())
}

// This program demonstrates that os/exec works normally after the 1.24.6 security patch.
// It runs the "echo" command and prints its output.
package main

import (
	"bytes"
	"fmt"
	"os/exec"
)

func main() {
	// Prepare the command: echo "Hello, world!"
	cmd := exec.Command("echo", "Hello, world!")
	var out bytes.Buffer
	cmd.Stdout = &out
	if err := cmd.Run(); err != nil {
		fmt.Println("command failed:", err)
		return
	}
	fmt.Print(out.String())
}

// This program demonstrates that the `mdbook` crate is not part of the
// standard library and therefore cannot be used directly in a minimal
// Rust 1.98.1 (edition 2024) program. It simply prints a message
// confirming that `mdbook` is an external dependency.

fn main() {
    println!("The `mdbook` crate is an external dependency and not available in the standard library.");
}

// This program demonstrates that the Rust language itself has not changed
// in July 2025.  The program simply prints a message confirming that
// the language compiler (rustc 1.98.1, edition 2024) is still the same
// as before the program‑management update.  No new syntax or APIs are
// used because the update only affects project coordination, not the
// language itself.

fn main() {
    // Print a simple confirmation message
    println!("Rust 1.98.1 (edition 2024) is unchanged by the July 2025 PM update.");
}

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