493 stories
·
4 followers

PHP 8: Constructor property promotion

1 Share

Personally, I use value objects and data transfer objects all the time in my projects. I even wrote a dedicated post on how to treat data in our code a while back.

Naturally, I'm very happy with the constructor property promotion RFC, it's passed and will be added in PHP 8. You see, this feature reduces a lot of boilerplate code when constructing simple objects such as VOs and DTOs.

In short: property promotion allows you to combine class fields, constructor definition and variable assignments all into one syntax, in the construct parameter list.

So instead of doing this:

class CustomerDTO
{
    public string $name;

    public string $email;

    public DateTimeImmutable $birth_date;

    public function __construct(
        string $name, 
        string $email, 
        DateTimeImmutable $birth_date
    ) {
        $this->name = $name;
        $this->email = $email;
        $this->birth_date = $birth_date;
    }
}

You would write this:

class CustomerDTO
{
    public function __construct(
        public string $name, 
        public string $email, 
        public DateTimeImmutable $birth_date,
    ) {}
}

Let's look at how it works!


# How it works

The basic idea is simple: ditch all the class properties and the variable assignments, and prefix the constructor parameters with public, protected or private. PHP will take that new syntax, and transform it to normal syntax under the hood, before actually executing the code.

So it goes from this:

class MyDTO
{
    public function __construct(
        public string $name = 'Brent',
    ) {}
}

To this:

class MyDTO
{
    public string $name;

    public function __construct(
        string $name = 'Brent'
    ) {
        $this->name = $name;
    }
}

And only executes it afterwards.

Note by the way that the default value is not set on the class property, but on the method argument in the constructor.

So let's look at what promoted properties can and can't do, there's quite a lot of little intricacies worth mentioning!


# Only in constructors

Promoted properties can only be used in constructors. That might seem obvious but I thought it was worth mentioning this, just to be clear.


# No duplicates allowed

You're not able to declare a class property and a promoted property with the same name. That's also rather logical, since the promoted property is simply transpiled to a class property at runtime.

class MyClass
{
    public string $a;

    public function __construct(
        public string $a,
    ) {}
}

# Untyped properties are allowed

You're allowed to promote untyped properties, though I'd argue that these days with modern PHP, you're better off typing everything.

class MyDTO
{
    public function __construct(
        public $untyped,
    ) {}
}

# Simple defaults

Promoted properties can have default values, but expressions like new … are not allowed.

public function __construct(
    public string $name = 'Brent',
    public DateTimeImmutable $date = new DateTimeImmutable(),
) {}

# Combining promoted- and normal properties

Not all constructor properties should be promoted, you can mix and match.

class MyClass
{
    public string $b;

    public function __construct(
        public string $a,
        string $b,
    ) {
        $this->b = $b;
    }
}

I'd say: be careful mixing the syntaxes, if it makes the code less clear, consider using a normal constructor instead.


# Access promoted properties from the constructor body

You're allowed to read the promoted properties in the constructor body. This can be useful if you want to do extra validation checks. You can use both the local variable and the instance variable, both work fine.

public function __construct(
    public int $a,
    public int $b,
) {
    assert($this->a >= 100);

    if ($b >= 0) {
        throw new InvalidArgumentException('…');
    }
}

# Doc comments on promoted properties

You can add doc comments on promoted properties, and they are still available via reflection.

class MyClass 
{
    public function __construct(
        /** @var string */
        public $a,
    ) {}
}
$property = new ReflectionProperty(MyClass::class, 'a');

$property->getDocComment(); // "/** @var string */"

# Attributes

Just like doc blocks, attributes are allowed on promoted properties. When transpiled, they will be present both on the constructor parameter, as well as the class property.

class MyClass
{
    public function __construct(
        <<MyAttribute>>
        public $a,  
    ) {}
}

Will be transpiled to:

class MyClass 
{
    <<MyAttribute>>
    public $a;
 
    public function __construct(
        <<MyAttribute>>
        $a,
    ) {
        $this->a = $a;
    }
}

# Not allowed in abstract constructors

I didn't even knew abstract constructors were a thing, but here goes! Promoted properties are not allowed in them.

abstract class A
{
    abstract public function __construct(
        public string $a,
    ) {}
}

# Allowed in traits

On the other hand, they are allowed in traits. This makes sense, since the transpiled syntax is also valid in traits.

trait MyTrait
{
    public function __construct(
        public string $a,
    ) {}
}

# var is not supported

Old, I mean, experienced PHP developers might have used var in a distant past to declare class variables. It's not allowed with constructor promotion. Only public, protected and private are valid keywords.

public function __construct(
    var string $a,
) {}

# Variadic parameters cannot be promoted

Since you can't convert to a type that's array of type, it's not possible to promote variadic parameters.

public function __construct(
    public string ...$a,
) {}

Still waiting for generics…


# Reflection for isPromoted

Both ReflectionProperty and ReflectionParameter have a new isPromoted method to check whether the class property or method parameter is promoted.


# Inheritance

Since PHP constructors don't need to follow the declaration of their parent constructor, there's little to be said: inheritance is allowed. If you need to pass properties from the child constructor to the parent constructor though, you'll need to manually pass them:

class A
{
    public function __construct(
        public $a,
    ) {}
}

class B extends A
{
    public function __construct(
        $a,
        public $b,    
    ) {
        parent::__construct($a);
    }
}

That's about it for property promotion! I for sure will use them, what about you? Let me know via Twitter or e-mail!


Read the whole story
chrisminett
31 days ago
reply
Milton Keynes, UK
Share this story
Delete

Slack rolling out major update with new nav bar, custom sidebar drop-downs, new shortcuts, more

1 Comment

Popular communication service Slack is out with a big update today that includes a new navigation bar, a more customizable sidebar with nested folder-type drop-down sections, improved shortcuts, and much more. The update is rolling out starting today, read on for everything that’s new.
more…

The post Slack rolling out major update with new nav bar, custom sidebar drop-downs, new shortcuts, more appeared first on 9to5Mac.

Read the whole story
chrisminett
135 days ago
reply
Hopefully this means we can finally put channels where we want, hide those rarely looked at, and stop drafts jumping people around!!
Milton Keynes, UK
Share this story
Delete

Christmas Presents

1 Comment and 9 Shares
"The parasitism might be mediated by a fungus!" exclaimed the biologist who was trying to ruin Christmas again.
Read the whole story
chrisminett
221 days ago
reply
Milton Keynes, UK
Share this story
Delete
1 public comment
alt_text_bot
223 days ago
reply
"The parisitism might be mediated by a fungus!" exclaimed the biologist who was trying to ruin Christmas again.

New ports database site

1 Share

MacPorts’ new ports database is live at ports.macports.org. Please consider installing the “mpstats” port to enable submission of anonymous information about your system and installed ports for statistical purposes.

The information collected is currently:

  • MacPorts version
  • OS name and version
  • CPU architecture
  • Selected C++ standard library
  • Xcode, command line tools, and GCC versions
  • Name, version, selected variants, and requested status of each installed port
  • A UUID so we can tell whether submissions are from distinct users

The site also shows which OS versions each port was successfully built on, has links to open Trac tickets, and more.

This new site is the result of much hard work by our GSoC student, Arjun Salyan. We hope you find it useful.

Read the whole story
chrisminett
351 days ago
reply
Milton Keynes, UK
Share this story
Delete

Typed properties in PHP

1 Comment

Typed class properties have been added in PHP 7.4 and provide a major improvement to PHP's type system. These changes are fully opt-in and non breaking to previous versions.

In this post we'll look at the feature in-depth, but first let's start by summarising the most important points:

  • They are available as of PHP 7.4, which is scheduled to be released in November of 2019
  • They are only available in classes and require an access modifier: public, protected or private; or var
  • All types are allowed, except void and callable

This is what they look like in action:

class Foo
{
    public int $a;

    public ?string $b = 'foo';

    private Foo $prop;

    protected static string $static = 'default';
}

If you're unsure about the added benefit of types, I'd recommend you reading this post first.

# Uninitialized

Before looking at the fun stuff, there's an important aspect about typed properties that's essential to talk about first.

Despite what you might think on first sight, the following code is valid:

class Foo
{
    public int $bar;
}

$foo = new Foo;

Even though the value of $bar isn't an integer after making an object of Foo, PHP will only throw an error when $bar is accessed:

var_dump($foo->bar);

Fatal error: Uncaught Error: Typed property Foo::$bar 
must not be accessed before initialization

As you can read from the error message, there's a new kind of "variable state": uninitialized.

If $bar didn't have a type, its value would simply be null. Types can be nullable though, so it's not possible to determine whether a typed nullable property was set, or simply forgotten. That's why "uninitialized" was added.

There are four important things to remember about uninitialized:

  • You cannot read from uninitialized properties, doing so will result in a fatal error.
  • Because uninitialized state is checked when accessing a property, you're able to create an object with an uninitialized property, even though its type is non-nullable.
  • You can write to an uninitialized property before reading from it.
  • Using unset on a typed property will make it uninitialized, while unsetting an untyped property will make it null.

Especially note that the following code, where an uninitialised, non-nullable property is set after constructing the object, is valid

class Foo
{
    public int $a;
}

$foo = new Foo;

$foo->a = 1;

While uninitialized state is only checked when reading the value of a property, type validation is done when writing to it. This means that you can be sure that no invalid type will ever end up as a property's value.

# Defaults and constructors

Let's take a closer look at how typed values can be initialized. In case of scalar types, it's possible to provide a default value:

class Foo
{
    public int $bar = 4;
    
    public ?string $baz = null;
    
    public array $list = [1, 2, 3];
}

Note that you can only use null as a default if the type is actually nullable. This might seem obvious, but there's some legacy behaviour with parameter defaults where the following is allowed:

function passNull(int $i = null)
{ /* … */ }

passNull(null);

Luckily this confusing behaviour is not allowed with typed properties.

Also note that it's impossible to have default values with object or class types. You should use the constructor to set their defaults.

The obvious place to initialize typed values would of course be the constructor:

class Foo
{
    private int $a;

    public function __construct(int $a)
    {
        $this->a = $a;
    }
}

But also remember what I mentioned before: it's valid to write to an uninitialized property, outside of the constructor. As long as there are nothing is reading from a property, the uninitialized check is not performed.

# Types of types

So what exactly can be typed and how? I already mentioned that typed properties will only work in classes (for now), and that they need an access modifier or the var key word in front of them.

As of available types, almost all types can be used, except void and callable.

Because void means the absence of a value, it makes sense that it cannot be used to type a value. callable however is a little more nuanced.

See, a "callable" in PHP can be written like so:

$callable = [$this, 'method'];

Say you'd have the following (broken) code:

class Foo
{
    public callable $callable;
    
    public function __construct(callable $callable)
    { /* … */ }
}

class Bar
{
    public Foo $foo;
    
    public function __construct()
    {
        $this->foo = new Foo([$this, 'method'])
    }
    
    private function method()
    { /* … */ }
}

$bar = new Bar;

($bar->foo->callable)();

In this example, $callable refers to the private Bar::method, but is called within the context of Foo. Because of this problem, it was decided not to add callable support.

It's no big deal though, because Closure is a valid type, which will remember the $this context where it was constructed.

With that out of the way, here's a list of all available types:

  • bool
  • int
  • float
  • string
  • array
  • iterable
  • object
  • ? (nullable)
  • self & parent
  • Classes & interfaces

# Coercion and strict types

PHP, being the dynamic language we love and hate, will try to coerce or convert types whenever possible. Say you pass a string where you expect an integer, PHP will try and convert that string automatically:

function coerce(int $i)
{ /* … */ }

coerce('1'); // 1

The same principles apply to typed properties. The following code is valid and will convert '1' to 1.

class Bar
{
    public int $i;
}

$bar = new Bar;

$bar->i = '1'; // 1

If you don't like this behaviour you can disabled it by declaring strict types:

declare(strict_types=1);

$bar = new Bar;

$bar->i = '1'; // 1

Fatal error: Uncaught TypeError: 
Typed property Bar::$i must be int, string used

# Type variance and inheritance

Even though PHP 7.4 introduced improved type variance, typed properties are still invariant. This means that the following is not valid:

class A {}
class B extends A {}

class Foo
{
    public A $prop;
}

class Bar extends Foo
{
    public B $prop;
}

Fatal error: Type of Bar::$prop must be A (as in class Foo)

If the above example doesn't seem significant, you should take a look at the following:

class Foo
{
    public self $prop;
}

class Bar extends Foo
{
    public self $prop;
}

PHP will replace self behind the scenes with the concrete class it refers to, before running the code. This means that the same error will be thrown in this example. The only way to handle it, is by doing the following:

class Foo
{
    public Foo $prop;
}

class Bar extends Foo
{
    public Foo $prop;
}

Speaking of inheritance, you might find it hard to come up with any good use cases to overwrite the types of inherited properties.

While I agree with that sentiment, it's worth noting that it is possible to change the type of an inherited property, but only if the access modifier also changes from private to protected or public.

The following code is valid:

class Foo
{
    private int $prop;
}

class Bar extends Foo
{
    public string $prop;
}

However, changing a type from nullable to non-nullable or reverse, is not allowed.

class Foo
{
    public int $a;
    public ?int $b;
}

class Bar extends Foo
{
    public ?int $a;
    public int $b;
}

Fatal error: Type of Bar::$a must be int (as in class Foo)

# There's more!

Like a said at the start of this post, typed properties are a major addition to PHP. There's lots more to say about them. I'd suggest you reading through the RFC to know all the neat little details.

If you're new to PHP 7.4, you probably want to read the full list of changes made and features added. To be honest, it's one of the best releases in a long time, and worth your time!

Finally, if you have any thoughts you want to share on the topic, I'd love to hear from you! You can reach me via Twitter or e-mail.

Until next time!

Read the whole story
chrisminett
385 days ago
reply
Looking forward to it!
Milton Keynes, UK
Share this story
Delete

Git Ransom Campaign Incident Report – Atlassian Bitbucket, GitHub, GitLab

1 Share

Background and Summary of Event

Today, Atlassian Bitbucket, GitHub, and GitLab are issuing a joint blog post, in a coordinated effort to help educate and inform users of the three platforms on secure best practices relating to the recent Git ransomware incident. Though there is no evidence Atlassian Bitbucket, GitHub, or GitLab products were compromised in any way, we believe it’s important to help the software development community better understand and collectively take steps to protect against this threat.

On Thursday, May 2nd, the security teams of Atlassian Bitbucket, GitHub, and GitLab learned of a series of user account compromises across all three platforms. These account compromises resulted in a number of public and private repositories being held for ransom by an unknown actor. Each of the teams investigated and assessed that all account compromises were the result of unintentional user credential leakage by users or other third-parties, likely on systems external to Bitbucket, GitHub, or GitLab.

The security and support teams of all three companies have taken and continue to take steps to notify, protect, and help affected users recover from these events. Further, the security teams of all three companies are also collaborating closely to further investigate these events in the interest of the greater Git community. At this time, we are confident that we understand how the account compromises and subsequent ransom events were conducted. This coordinated blog post will outline the details of the ransom event, provide additional information on how our organizations protect users, and arm users with information on recovering from this event and preventing others.

Event Details

On the evening of May 2nd (UTC), all three companies began responding to reports that user repositories, both public and private, were being wiped and replaced with a single file containing the following ransom note:

> To recover your lost data and avoid leaking it: Send us 0.1 Bitcoin (BTC) to our Bitcoin address 1ES14c7qLb5CYhLMUekctxLgc1FV2Ti9DA and contact us by Email at admin@gitsbackup.com with your Git login and a Proof of Payment. If you are unsure if we have your data, contact us and we will send you a proof. Your code is downloaded and backed up on our servers. If we dont receive your payment in the next 10 Days, we will make your code public or use them otherwise.

Through immediate independent investigations, all three companies observed that user accounts were compromised using legitimate credentials including passwords, app passwords, API keys, and personal access tokens. Subsequently, the bad actor performed command line Git pushes to repositories accessible to these accounts at very high rates, indicating automated methods. These pushes overwrote the repository contents with the ransom note above and erased the commit history of the remote repository. Incident responders from each of the three companies began collaborating to protect users, share intelligence, and identify the source of the activity. All three companies notified the affected users and temporarily suspended or reset those accounts in order to prevent further malicious activity.

During the course of the investigation, we identified a third-party credential dump being hosted by the same hosting provider where the account compromise activity had originated. That credential dump comprised roughly one third of the accounts affected by the ransom campaign. All three companies acted to invalidate the credentials contained in that public dump.

Further investigation showed that continuous scanning for publicly exposed `.git/config` and other environment files has been and continues to be conducted by the same IP address that conducted the account compromises, as recently as May 10th. These files can contain sensitive credentials and personal access tokens if care is not taken to prevent their inclusion, and they should not be publicly accessible in repositories or on web servers. This problem is not a new one. More information on the `.git` directory and the `.git/config` file is available here and here. Additional IPs residing on the same hosting provider are also exhibiting similar scanning behavior. We are confident that this activity is the source of at least a portion of the compromised credentials.

Known ransom activity ceased on May 2nd. All known affected users have had credentials reset or revoked, and all known affected users have been notified by all three companies. We recommend all users take steps to protect themselves from such attacks, more information on doing so and on restoring affected repositories is available below.

How to Protect Yourself

Enable multi-factor authentication on your software development platform of choice.

Use strong and unique passwords for every service.

  • Strong and unique passwords prevent credential reuse if a third-party experiences a breach and leaks credentials.
  • Use a password manager (if approved by your organization) to make this easier!

Understand the risks associated with the use of personal access tokens.

  • Personal access tokens, used via Git or the API, circumvent multi-factor authentication.
  • Tokens may have read/write access to repositories depending on scope and should be treated like passwords.
  • If you enter your token into the clone URL when cloning or adding a remote, Git writes it to your `.git/config` file in plain text, which may carry a security risk if the `.git/config` file is publicly exposed.
  • When working with the API, use tokens as environment variables instead of hardcoding them into your programs.

Do not expose `.git` directories and `.git/config` files containing credentials or tokens in public repositories or on web servers.

How to Recover an Affected Repository

If you have a full current copy of the repository on your computer, you can force push to the current HEAD of your local copy using:

`git push origin HEAD:master –force`

Otherwise, you can still clone the repository and make use of:

Additional assistance on Git usage is available in the following resources:

Should you require additional assistance recovering your repository contents, please refer to the following:

Bitbucket:

GitHub:

GitLab:

What the Software Development Platform Community is Doing to Protect Users

All three platforms provide robust multi-factor authentication options:

Bitbucket provides the ability for admins to require 2-factor authentication and the ability to restrict access to users on certain IP addresses (IP Whitelisting) on their Premium plan.

GitHub provides token scanning to notify a variety of service providers if secrets are published to public GitHub repositories. GitHub also provides extensive guidance on preventing unauthorized account access. We encourage all users to enable two-factor authentication.

GitLab provides secrets detection in 11.9 as part of the SAST functionality. We also encourage users to enable 2FA here, and setting up ssh keys.

Thanks to the security and support teams of Atlassian Bitbucket, GitHub, and GitLab, including the following individuals for their contributions to this investigation and blog post: Mark Adams, Ethan Dodge, Sean McLucas, Elisabeth Nagy, Gary Sackett, Andrew Wurster (Atlassian Bitbucket); Matt Anderson, Howard Draper, Jay Swan, John Swanson (GitHub); Paul Harrison, Anthony Saba, Jan Urbanc, Kathy Wang (GitLab).




The post Git Ransom Campaign Incident Report – Atlassian Bitbucket, GitHub, GitLab appeared first on Bitbucket.

Read the whole story
chrisminett
447 days ago
reply
Milton Keynes, UK
Share this story
Delete
Next Page of Stories