The Big Programming Thread - Page 785

ArrayList<String> animals = new ArrayList<String>();
animals.add("bat");
animals.add("owl");
animals.add("bat");
animals.add("bat");

int occurrences = Collections.frequency(animals, "bat"); // will return 3

On October 24 2016 04:57 travis wrote:

Show nested quote +

On October 24 2016 04:50 Manit0u wrote:
It seems to me you're not using Google enough

Big part of the fun with programming is doing the research and trying to figure things out yourself (especially simple ones like that).

That's really not true. Particularly for this. There is next to no explanation how I could implement my own iterator for a hashtable. At least that I could find, and I did quite a bit of looking.

Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();

while(iterator.hasNext()) {
    Map.Entry<Integer, String> entry = iterator.next();

    System.out.printf("Key : %s and Value: %s %n", entry.getKey(), entry.getValue());

    iterator.remove(); // right way to remove entries from Map, avoids ConcurrentModificationException
}

[
  "somekey"  : 2,
  "otherkey" : 1,
]

abstract class Crypto
{
    const CIPHER = 'aes-256-cbc';
    const HMAC_ALGO = 'sha256';

    /**
     * Number of bytes generated for encryption key
     * 64 = 512-bit
     * 32 = 256-bit
     * 16 = 128-bit
     */
    const CSPRNG_BYTES = 32;
    /**
     * Number of characters generated for HMAC (hex)
     */
    const HMAC_XBYTES = 64;

    /**
     * @param string $data - data to encrypt
     * @param string|null $encryptionKey - hex
     * @return string - encrypted data
     */
    final public static function encrypt($data, $encryptionKey = null)
    {
        if (null === $encryptionKey) {
            $encryptionKey = static::getEncryptionKey();
        }

        $data .= static::getHMAC($data, $encryptionKey); // add authentication code
        $iv = static::getInitializationVector();

        $encrypted = openssl_encrypt(
            $data,
            self::CIPHER,
            hex2bin($encryptionKey),
            OPENSSL_RAW_DATA,
            $iv
        );

        return sprintf('%s|%s', base64_encode($encrypted), base64_encode($iv));
    }

    /**
     * @param string $encrypted - encrypted data
     * @param string|null $encryptionKey - hex
     * @return bool|string - decrypted data or false on failure
     */
    final public static function decrypt($encrypted, $encryptionKey = null)
    {
        list($data, $iv) = explode('|', $encrypted);

        if (null === $encryptionKey) {
            $encryptionKey = static::getEncryptionKey();
        }

        $decrypted = openssl_decrypt(
            base64_decode($data),
            self::CIPHER,
            hex2bin($encryptionKey),
            OPENSSL_RAW_DATA,
            base64_decode($iv)
        );

        if (!static::validHMAC($decrypted, $encryptionKey)) {
            return false;
        }

        return substr($decrypted, 0, -self::HMAC_XBYTES);
    }

    /**
     * Generate a keyed-hash message authentication code (HMAC)
     *
     * @param string $data - data to be encrypted
     * @param string $key - encryption key (hex)
     * @return string
     */
    final public static function getHMAC($data, $key)
    {
        return hash_hmac(self::HMAC_ALGO, $data, $key);
    }

    /**
     * @param $data - decrypted data with hmac
     * @param $key - encryption key (hex)
     * @return bool
     */
    final public static function validHMAC($data, $key)
    {
        $expected = static::getHMAC(substr($data, 0, -self::HMAC_XBYTES), $key);
        $hmac = substr($data, -self::HMAC_XBYTES);

        return $hmac === $expected;
    }

    /**
     * Generate a fixed-size input to a cryptographic primitive
     *
     * @return string - binary string
     */
    final public static function getInitializationVector()
    {
        return openssl_random_pseudo_bytes(static::getVectorSize());
    }

    /**
     * Get size of starting value for specific cipher
     *
     * @return int
     */
    final public static function getVectorSize()
    {
        return openssl_cipher_iv_length(self::CIPHER);
    }

    /**
     * Use cryptographically secure pseudo-random number generator (CSPRNG)
     * to generate a desired length of bytes
     *
     * @return string - binary string
     */
    final public static function generateRandomKey()
    {
        return openssl_random_pseudo_bytes(self::CSPRNG_BYTES);
    }
}