Quale libreria o software firmare e verificare ciecamente?

Question

Recentemente ho sentito delle firme cieche. Ho visto l'articolo di Wikipedia su come funzionano, ma non ho voglia di implementarlo. Quali librerie (preferibilmente compatibile con linux e windows) posso utilizzare per implementare firme cieche e verificare che il file sia firmato?

Ho provato a guardare le pagine man di OpenSSL, ma non credo che supporta le firme cieche http://www.openssl.org/docs/apps/dgst.html

posso realizzare la mia app in C++ o .NET e non hanno problemi di processo di riproduzione e le loro uscite parsing comunque un lib sarebbe preferito rispetto al software.

Answer 1

Non è necessario alcun supporto speciale per le firme cieche. Devi semplicemente essere in grado di firmare e verificare un messaggio. La parte cieca dipende dal sistema che utilizza il codice asimmetrico. La semplice firma di contenuti che ricevi in ​​un formato speciale potrebbe costituire una firma cieca, che indica i dati passati attraverso di te prima di andare da qualche altra parte. Just make sure you don't use RSA

EDIT

Come per la discussione estesa nei commenti di questa risposta, il testo di cui sopra può essere fuorviante a seconda di cosa si sta parlando di specifico. Se hai intenzione di completare la firma cieca come descritto nei commenti a questa risposta, allora avrai bisogno di un supporto speciale. Direi che se non riesci a trovare qualcosa recensito e testato, sarebbe un ottimo esercizio o progetto per implementare il tuo e pubblicarlo su GitHub o simili.

Answer 2

Posso implementare la mia app in C++ o .NET ... Quale libreria o software firmare e verificare ciecamente?

Ecco una risposta basata su Crypto++. Crypto ++ è una libreria di classi di schemi crittografici scritta da Wei Dai. L'esempio è stato preso da Raw RSA | Blind Signatures sul wiki.

Jack Lloyd's Botan, che è una libreria C++ 11 crypto e TLS, può avere il supporto della firma nativa per non vedenti.

Crypto ++ manca classi di firma cieche. Il metodo seguente segue l'algoritmo di base come dettagliato a Blind Signatures. Tuttavia, si differenzia da Wikipedia applicando il controllo incrociato s(s'(x)) = x. Il controllo incrociato era presente in Chaum's original paper, ma manca nell'articolo wiki. Una seconda differenza rispetto al documento di Chaum e a wikipedia è che il codice seguente utilizza H(m) anziché m. Ciò è dovuto a Rabin in 1979.

È possibile applicare prima una funzione di riempimento per Usability of padding scheme in blinded RSA signature? o RSA blind signatures in practice. Anche vedere Is there a standard padding/format for RSA Blind Signatures?

---

#include "cryptlib.h" 
#include "integer.h" 
#include "nbtheory.h" 
#include "osrng.h" 
#include "rsa.h" 
#include "sha.h" 
using namespace CryptoPP; 

#include <iostream> 
#include <stdexcept> 
using std::cout; 
using std::endl; 
using std::runtime_error; 

int main(int argc, char* argv[]) 
{ 
    // Bob artificially small key pair 
    AutoSeededRandomPool prng; 
    RSA::PrivateKey privKey; 

    privKey.GenerateRandomWithKeySize(prng, 64); 
    RSA::PublicKey pubKey(privKey); 

    // Convenience 
    const Integer& n = pubKey.GetModulus(); 
    const Integer& e = pubKey.GetPublicExponent(); 
    const Integer& d = privKey.GetPrivateExponent(); 

    // Print params 
    cout << "Pub mod: " << std::hex << pubKey.GetModulus() << endl; 
    cout << "Pub exp: " << std::hex << e << endl; 
    cout << "Priv mod: " << std::hex << privKey.GetModulus() << endl; 
    cout << "Priv exp: " << std::hex << d << endl; 

    // For sizing the hashed message buffer. This should be SHA256 size. 
    const size_t SIG_SIZE = UnsignedMin(SHA256::BLOCKSIZE, n.ByteCount()); 

    // Scratch 
    SecByteBlock buff1, buff2, buff3; 

    // Alice original message to be signed by Bob 
    SecByteBlock orig((const byte*)"secret", 6); 
    Integer m(orig.data(), orig.size()); 
    cout << "Message: " << std::hex << m << endl; 

    // Hash message per Rabin (1979) 
    buff1.resize(SIG_SIZE); 
    SHA256 hash1; 
    hash1.CalculateTruncatedDigest(buff1, buff1.size(), orig, orig.size()); 

    // H(m) as Integer 
    Integer hm(buff1.data(), buff1.size()); 
    cout << "H(m): " << std::hex << hm << endl; 

    // Alice blinding 
    Integer r; 
    do { 
     r.Randomize(prng, Integer::One(), n - Integer::One()); 
    } while (!RelativelyPrime(r, n)); 

    // Blinding factor 
    Integer b = a_exp_b_mod_c(r, e, n); 
    cout << "Random: " << std::hex << b << endl; 

    // Alice blinded message 
    Integer mm = a_times_b_mod_c(hm, b, n); 
    cout << "Blind msg: " << std::hex << mm << endl; 

    // Bob sign 
    Integer ss = privKey.CalculateInverse(prng, mm); 
    cout << "Blind sign: " << ss << endl; 

    // Alice checks s(s'(x)) = x. This is from Chaum's paper 
    Integer c = pubKey.ApplyFunction(ss); 
    cout << "Check sign: " << c << endl; 
    if (c != mm) 
     throw runtime_error("Alice cross-check failed"); 

    // Alice remove blinding 
    Integer s = a_times_b_mod_c(ss, r.InverseMod(n), n); 
    cout << "Unblind sign: " << s << endl; 

    // Eve verifies 
    Integer v = pubKey.ApplyFunction(s);  
    cout << "Verify: " << std::hex << v << endl; 

    // Convert to a string 
    size_t req = v.MinEncodedSize(); 
    buff2.resize(req); 
    v.Encode(&buff2[0], buff2.size()); 

    // Hash message per Rabin (1979) 
    buff3.resize(SIG_SIZE); 
    SHA256 hash2; 
    hash2.CalculateTruncatedDigest(buff3, buff3.size(), orig, orig.size()); 

    // Constant time compare 
    bool equal = buff2.size() == buff3.size() && VerifyBufsEqual(
     buff2.data(), buff3.data(), buff3.size()); 

    if (!equal) 
     throw runtime_error("Eve verified failed"); 

    cout << "Verified signature" << endl; 

    return 0; 
} 

Qui è il risultato di compilare ed eseguire il programma:

$ g++ blind.cxx ./libcryptopp.a -o blind.exe 
$ ./blind.exe 
Pub mod: bbf62585f8486acbh 
Pub exp: 11h 
Priv mod: bbf62585f8486acbh 
Priv exp: 31c1280c6bb08635h 
Message: 736563726574h 
H(m): 2bb80d537b1da3e3h 
Random: 7db0ecdb0a09fad5h 
Blinded msg: a8bf62a25b7b4b53h 
Blind sign: 2646ab6b9d5b48dfh 
Check sign: a8bf62a25b7b4b53h 
Unblind sign: 418d211b9cbb2d00h 
Verify: 2bb80d537b1da3e3h 
Verified signature