Simple proof-of-work (based on HashCash)
public HashCash() throws NoSuchAlgorithmException {

SHA-256 is a requirement for any Java SE environment. Instead of throwing you should be catching and converting to a RuntimeException (or IllegalStateException) with this particular exception as cause.
public long generateHashCash(final String seed, final int targetLevel) {
...
private final int getSecurityLevel(final String value) {

If you're going to design for performance you should not be using String types. The seed should be a byte array from the start. And you could use e.g. ByteBuffer to write an integer to an existing array that already starts with the seed.
Note that SHA-256 is a Merkle-Damgard hash function that handles input block-by-block. That means that if you start off with a large enough seed (512 bits or larger) you might as well pre-hash it. Of course this means mucking about within the hash implementation.
if(b != 0)
    break;
level++;

Generally the level calculation is performed on bits or even values (where the hash value, when seen as a unsigned number, is below a certain value).
As for performance: you can stop comparing whenever you encounter a number that doesn't have the right level. It won't matter much when compared the time required to perform SHA-256 in all probability, but it is still wasteful.
I don't expect getSecurityLevel to perform the actual hash calculation. A getter is generally not expected to perform any work at all.
The PHP code doesn't seem to reflect the structure of the Java application. If you have one getSecurityLevel method I would expect the same in the verification application, whichever language is used.

Otherwise, yes, it is a very simple proof of work. I'd rather require a few hashes instead of one, to average out the amount of work performed. With just one hash there will be a lot of luck involved, and the actual work will therefore vary rather wildly.
In the unlikely case that you've invented yet another popular PoW: I'd use 128 bits rather than a 64 bit long. It's pretty easy to make a counter that operates on bytes directly, so you would not even have to convert to the binary values required for the hashing.