Hírolvasó

[$] The return of None-aware operators for Python

1 év 7 hónap óta
The saga of the None-aware (or null-coalescing) operators for Python continues. We last looked in on the topic a little over a year ago and noted that either adoption or a clear rejection of the idea might help tamp down its regular recurrence. That has not happened, so, predictably, it was raised again—and does not look any closer to resolution this time around.
jake

Computer science pioneer Niklaus Wirth passes away (ITWire)

1 év 7 hónap óta
ITWire covers the passing of Niklaus Wirth.

Wirth is well-remembered for his pioneering work in programming languages and algorithms. For these achievements, he received the ACM Turing Award in 1984, inducted as a Fellow of the ACM in 1994, and a Fellow of the Computer History Museum in 2004.

They include, among many, being chief designer for the programming languages Euler (1965), PL360 (1966), ALGOL W (1968), Pascal (1970), Modula (1975), Modula-2 (1978), Oberon (1987), Oberon-2 (1991), and Oberon-07 (2007).

corbet

Security updates for Thursday

1 év 7 hónap óta
Security updates have been issued by Oracle (firefox, gstreamer1-plugins-bad-free, thunderbird, tigervnc, and xorg-x11-server), Red Hat (squid:4), SUSE (exim, libcryptopp, and proftpd), and Ubuntu (openssh and sqlite3).
jake

[$] Smuggling email inside of email

1 év 7 hónap óta
Normally, when a new vulnerability is discovered and releases are coordinated with those affected, the announcement is done at a convenient time—not generally right before the end-of-year holidays, for example. The SMTP Smuggling vulnerability has taken a different path, however, with its announcement landing on December 18. That may well have been unpleasant for some administrators that had not yet updated, but it was particularly problematic for some projects that had not been made aware of the vulnerability at all—though it was known to affect several open-source mailers.
jake

Lenôtre: Maestro - Introduction

1 év 7 hónap óta
On his blog, Luc Lenôtre introduces Maestro, "a Unix-like kernel and operating system written from scratch in Rust". Maestro is intended to be "lightweight and compatible-enough with Linux to be usable in everyday life". The project began, in C, back in 2018, but switched over to Rust after a year-and-a-half. The current status: Maestro is a monolithic kernel, supporting only the x86 (in 32 bits) architecture for now.

At the time of writing, 135 out of 437 Linux system calls (roughly 31%) are more or less implemented. The project has 48 800 lines of code across 615 files (all repositories combined, counted using the cloc command).

There is a Hacker News discussion of the project as well.

jake

Vim 9.1 released

1 év 7 hónap óta
Version 9.1 of the Vim editor has been released. "This release is dedicated to Bram Moolenaar, Vim's lead developer for more than 30 years, who passed away half a year ago. The Vim project wouldn't exist without his work". Changes include new support for classes and objects in the scripting language, smooth scrolling support, an EditorConfig plugin, and more.
corbet

Security updates for Wednesday

1 év 7 hónap óta
Security updates have been issued by Debian (kernel), Fedora (slurm), Oracle (kernel and postgresql:15), Red Hat (firefox, gstreamer1-plugins-bad-free, thunderbird, tigervnc, and xorg-x11-server), SUSE (polkit, postfix, putty, w3m, and webkit2gtk3), and Ubuntu (nodejs).
corbet

Rusty Russell: OP_SEGMENT: Allowing Introspection to Check Partial Scripts

1 év 7 hónap óta

In my previous post on Examing scriptpubkeys in Script I pointed out that there are cases where we want to require a certain script condition, but not an exact script: an example would be a vault-like covenant which requires a delay, but doesn’t care what else is in the script.

The problem with this is that in Taproot scripts, any unknown opcode (OP_SUCCESSx) will cause the entire script to succeed without being executed, so we need to hobble this slightly. My previous proposal of some kind of separator was awkward, so I’ve developed a new idea which is simpler.

Introducing OP_SEGMENT

Currently, the entire tapscript is scanned for the OP_SUCCESS opcodes, and succeeds immediately if one it found. This would be modified:

  1. The tapscript is scanned for either OP_SEGMENT or OP_SUCCESSx.
  2. If OP_SEGMENT is found, the script up to that point is executed. If the script does not fail, scanning continues from that point.
  3. If OP_SUCCESSx is found, the script succeeds.

This basically divides the script into segments, each executed serially. It’s not quite as simple as “cut into pieces by OP_SEGMENT and examine one at a time” because the tapscript is allowed to contain things which would fail to decode altogether, after an OP_SUCCESSx, and we want to retain that property.

When OP_SEGMENT is executed, it does nothing: it simply limits the range of OP_SUCCESS opcodes.

Implementation

The ExecuteWitnessScript would have to be refactored (probably as a separate ExecuteTapScript since 21 of its 38 lines are an “if Tapscript” anyway), and it also implies that the stack limits for the current tapscript would be enforced upon encountering OP_SEGMENT, even if OP_SUCCESS were to follow after.

Interestingly, the core EvalScript function wouldn’t change except to ignore OP_SEGMENT, as it’s already fairly flexible.

Note that I haven’t implemented it yet, so there may yet be surprises, but I plan to prototype after the idea has received some review!

Enjoy!