Protezione degli indirizzi email se i loro hash sono pubblicamente disponibili

Sto lavorando a un progetto, in cui gli hash degli indirizzi email degli utenti saranno disponibili pubblicamente e devo impedire che vengano rapidamente scoperti dagli spammer.

L'idea principale dell'impresa è quella di offrire a chiunque conosca già gli indirizzi e-mail un modo semplice per trovare utenti da loro, ma rende difficile scoprire le e-mail con una semplice enumerazione di possibili alternative.

Quello che ho pensato è usare BCrypt o PBKDF2 per creare gli hash, e usare salt per creare hash dove la somma dei byte nel primo tempo è uguale alla somma dei byte nella seconda metà.

Ecco come potrebbe essere l'algoritmo:

    static byte[] GenerateMagicSignature(string text)
    {
        long id = 0;
        const int nParts = 2;
        while (true)
        {
            var key = BitConverter.GetBytes(id);

            for (long i = 0; i < id+1; i++)
            {
                var dd = new HMACSHA256(key);//replaced new encoding....
                key = dd.ComputeHash(key); 
            }

            var b=new Rfc2898DeriveBytes(text,key,10000);

            var sig=b.GetBytes(32);
            id++;
            var pts = SplitIntoPartsAndSum(sig, nParts);

            int val = pts[0];

            bool wrong = false;
            for (int i = 1; i < pts.Length; i++)
            {
                if (val!=pts[i])
                {
                    wrong = true;
                    break;
                }
            }

            if (wrong)
            {
                continue;
            }


            return sig;
        }
    }

    static int[] SplitIntoPartsAndSum(byte[] data, int parts)
    {
        var sums=new List<int>();

        for (int i = 0; i < parts; i++)
        {
            int sum = 0;
            var start = i*data.Length/parts;
            var end = (i + 1)*data.Length/parts;
            if (i==parts-1)
            {
                end = data.Length;
            }
            for (int j = start; j < end; j++)
            {
                sum += data[j];
            }

            sums.Add(sum);
        }

        return sums.ToArray();
    }

Il tempo medio di hashing per un indirizzo email conosciuto con queste impostazioni è di circa 1 minuto su una singola CPU. Quale ora può essere diviso per 5000 core di cuda, se capisco correttamente questa roba (o l'uso di PBKDF2 ridurrà significativamente quel numero?).

La mia domanda è: farlo è una buona idea, o devo ripensare a tutta la faccenda? Il mio obiettivo non è quello di rendere gli indirizzi e-mail completamente protetti, ma rendere più difficile per l'attaccante ottenerli rispetto, ad esempio, inviando query a Facebook e controllando se conosce o meno quelle e-mail.