}
            Hasher hasher = Hashing.newHasher();
            hasher.putHash(DIR_SIGNATURE);
            for (FileSystemLocationSnapshot child : children) {
                hasher.putString(child.getName());
                hasher.putHash(child.getHash());
            }
            return new DirectorySnapshot(absolutePath, name, accessType, hasher.hash(), children);
        }
    }

 * <h3>Memory considerations</h3>
 * <p>
 * Hashes by default are stored in {@link ByteArrayBackedHashCode a byte array}.
 * For a 128-bit hash this results in 64 bytes of memory used for each {@code HashCode}.
 * This implementation also requires GC to track two separate objects (the {@code HashCode} object and its {@code byte[]}).
 * <p>
 * Because Gradle uses a lot of MD5 hashes, for 128-bit hashes we have a more efficient implementation.

        this.rootHashes = rootHashes;
    }

    @Override
    public HashCode getHash() {
        if (hash == null) {
            Hasher hasher = Hashing.newHasher();
            hashingStrategy.appendToHasher(hasher, fingerprints.values());
            hash = hasher.hash();
        }
        return hash;
    }

    @Override
    public boolean isEmpty() {

        def file = file('foo') << contents
        def delegate = Mock(ResourceHasher)
        def hasher = LineEndingNormalizingResourceHasher.wrap(delegate, LineEndingSensitivity.NORMALIZE_LINE_ENDINGS)

        when:
        hasher.hash(snapshotContext(file))

        then:
        0 * delegate._

        when:
        hasher.hash(zipContext(file))

        then:
        0 * delegate._

        where:

    }

    /**
     * Returns empty if the file is detected to be a binary file
     */
    private Optional<HashCode> hash(InputStream inputStream) throws IOException {
        PrimitiveHasher hasher = Hashing.newPrimitiveHasher();

        hasher.putHash(SIGNATURE);

        try (BufferedInputStream input = new BufferedInputStream(CloseShieldInputStream.wrap(inputStream), BUFFER_SIZE)) {
            int peekAhead = -1;

package maphash

// A Seed is a random value that selects the specific hash function
// computed by a [Hash]. If two Hashes use the same Seeds, they
// will compute the same hash values for any given input.
// If two Hashes use different Seeds, they are very likely to compute
// distinct hash values for any given input.
//
// A Seed must be initialized by calling [MakeSeed].

        when:
        hasher.hash(zipEntry('META-INF/foo'))
        hasher.hash(zipEntry('META-INF/foo/MANIFEST.MF'))
        hasher.hash(zipEntry('META-INF/properties'))
        hasher.hash(zipEntry('META-INF/build.propertiesX'))
        hasher.hash(zipEntry('bar.properties'))
        hasher.hash(zipEntry('resources/foo.properties'))
        hasher.hash(zipEntry('foo'))
        hasher.hash(zipEntry('org/gradle/foo.class'))

    }

    def "delegate configuration is added to hasher"() {
        def configurationHasher = Mock(Hasher)
        delegate = Mock(ResourceHasher)

        when:
        filteredHasher.appendConfigurationToHasher(configurationHasher)

        then:
        1 * delegate.appendConfigurationToHasher(configurationHasher)
    }

Der Dieb kann also nicht versuchen, die gleichen Passwörter in einem anderen System zu verwenden (da viele Benutzer überall das gleiche Passwort verwenden, wäre dies gefährlich).

## `passlib` installieren

PassLib ist ein großartiges Python-Package, um Passwort-Hashes zu handhaben.

        val root = this@hashWithoutMessages
        val hasher = Hashing.newHasher()
        for (failure in sequence { visitFailures(root) }) {
            hasher.putString(failure.exceptionType.name)
            for (element in failure.stackTrace) {
                hasher.putString(element.toString())
            }
        }
        return hasher.hash()
    }

    private