Jaką bibliotekę lub oprogramowanie można podpisać i zweryfikować na ślepo?

Question

Niedawno słyszałem o ślepych podpisach. Widziałem artykuł wikipedia o tym, jak działają, ale nie ma ochoty go wdrażać. Jakie biblioteki (najlepiej kompatybilne z linuxem i oknami) mogę użyć do wdrożenia podpisów niewidomych i weryfikacji podpisania pliku?

Próbowałem patrząc na stronach man openssl, ale nie sądzę, że obsługuje podpisy niewidomym http://www.openssl.org/docs/apps/dgst.html

mogę wdrożyć moją aplikację w jednej lub C++ .NET i mieć żadnych problemów procesu tarła i analizowania ich wyników jednak lib byłby bardziej preferowany niż oprogramowanie.

Answer 1

Nie potrzebujesz specjalnego wsparcia dla podpisów niewidomych. Musisz po prostu podpisać i zweryfikować wiadomość. Część niewidoczna jest zależna od systemu za pomocą asymetrycznego szyfru. Po prostu podpisywanie treści, które otrzymujesz w specjalnym formacie, może oznaczać ślepe podpisywanie, wskazując przekazane przez ciebie dane przed udaniem się w inne miejsce. Just make sure you don't use RSA

EDIT

Jak na dłuższy dyskusji w komentarzach Ta odpowiedź jest powyższy tekst może być mylące, w zależności od tego, czego mówiąc konkretnie. Jeśli masz zamiar ukończyć ślepe podpisywanie, jak opisano w komentarzach do tej odpowiedzi, będziesz potrzebować specjalnego wsparcia. Powiedziałbym, że jeśli nie możesz znaleźć czegoś sprawdzonego i przetestowanego, byłoby fajnym ćwiczeniem lub projektem do wdrożenia własnego i opublikowania go na GitHub lub podobnym.

Answer 2

Mogę wdrożyć moją aplikację w C++ lub .NET ... Jakie lib lub oprogramowanie do podpisu i weryfikacji na ślepo?

Oto odpowiedź oparta na Crypto++. Crypto ++ to biblioteka klas schematów kryptograficznych napisanych przez Wei Dai. Przykład został pobrany z wiki na stronie Raw RSA | Blind Signatures.

Jack Lloyd's Botan, który jest biblioteką Crypto i TLS C++ 11, może mieć natywną obsługę podpisów w ciemno.

W Crypto ++ brakuje klas sygnatur. Poniższa metoda jest zgodna z podstawowym algorytmem opisanym szczegółowo pod numerem Blind Signatures. Różni się jednak od Wikipedii, stosując sprawdzanie krzyżowe s(s'(x)) = x. Sprawdzanie krzyżowe było obecne w Chaum's original paper, ale brakuje go w artykule wiki. Druga różnica od papieru Chauma i wikipedii, kod poniżej używa H(m) zamiast m. To z powodu Rabin in 1979.

Możesz najpierw zastosować funkcję wypełnienia dla każdego: Usability of padding scheme in blinded RSA signature? lub RSA blind signatures in practice. Zobacz także 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; 
} 

Oto wynik budynku i uruchomienie programu:

$ 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