Mapping crittografia RSA Parametri da CRT (teorema cinese del resto) in formato .NET

Question

Ho bisogno di implementare RSA crittografia/decrittografia utilizzando C#

ho una chiave privata con i seguenti parametri:

mod n, exponent, p , q, dP, dQ, e (p-1mod q)

parametri di cui sopra sono spiegare Ed in Chinese remainder algorithm

Tuttavia C# .NET applicazione della RSA ha diversi set di parametri come segue:

Modulus, Exponent, P, Q, DP, DQ, D, InverseQ

quando sto cercando per mappare i dati da CRT a DOTNET, ottengo l'errore Bad Data

per p, q, dP e dQ la mappatura è ovvia ma per il resto dei parametri non sono sicuro.

Sarebbe bello se posso ottenere aiuto mappatura questi paramters

Answer 1

mod n mappe per Modulus, p-1mod q mappe a InverseQ, le mappe crittografia esponente a Exponent e le mappe esponente a D decrittazione.

L'esponente di crittografia e e l'esponente di decrittografia d sono correlati da e * d = 1 mod (p-1) (q-1). Quindi se ne possiedi uno puoi facilmente ricavare l'altro usando alcuni metodi della classe System.Numerics.BigInteger.

var Pminus1 = BigInteger.Subtract(P, BigInteger.One); 
var Qminus1 = BigInteger.Subtract(Q, BigInteger.One); 
var Phi = BigInteger.Multiply(Pminus1, Qminus1); 
var PhiMinus1 = BigInteger.Subtract(Phi, BigInteger.One); 
// var D = BigInteger.ModPow(E, PhiMinus1, Phi); 

Nota che la cura deve essere presa quando la costruzione di un BigInteger .NET, soprattutto se siete abituati alla classe BigInteger di Java. Vedere this question per ulteriori informazioni.

EDIT:

Come CodeInChaos sottolinea che ultima riga è SBAGLIATO!

SBAGLIATO! SBAGLIATO! SBAGLIATO!

Sono imbarazzato. In un arco alle forze del male, la classe BigInteger non ha un metodo inverso modulare né un metodo esteso di algoritmo euclideo. Puoi comunque google per 'C# esteso algoritmo euclideo' puoi trovare molte implementazioni. L'algoritmo euclideo esteso fornirà interi x e y tali che 1 = e * x + phi * y. x è l'inverso di e mod phi, quindi l'impostazione D = x mod phi è ciò che è necessario.

Answer 2

D può essere calcolato in questo modo:

var qq = BigInteger.Multiply(phi, n); 
    var qw = BigInteger.Multiply(phi, qq); 
    BigInteger D = BigInteger.ModPow(e, (qw - 1), phi); 

Answer 3

estesa algoritmo di Euclide può essere utilizzato per calcolare l'inverso modulare, in questo caso D sarà calcolato, utilizzare questo link: http://www.di-mgt.com.au/euclidean.html#extendedeuclidean per ottenere dettaglio, I testato il codice sorgente in C# come sotto, e il risultato è corrispondente,

public static BigInteger modinv(BigInteger u, BigInteger v) 
{ 
    BigInteger inv, u1, u3, v1, v3, t1, t3, q; 
    BigInteger iter; 
    /* Step X1. Initialise */ 
    u1 = 1; 
    u3 = u; 
    v1 = 0; 
    v3 = v; 
    /* Remember odd/even iterations */ 
    iter = 1; 
    /* Step X2. Loop while v3 != 0 */ 
    while (v3 != 0) 
    { 
     /* Step X3. Divide and "Subtract" */ 
     q = u3/v3; 
     t3 = u3 % v3; 
     t1 = u1 + q * v1; 
     /* Swap */ 
     u1 = v1; v1 = t1; u3 = v3; v3 = t3; 
     iter = -iter; 
    } 
    /* Make sure u3 = gcd(u,v) == 1 */ 
    if (u3 != 1) 
     return 0; /* Error: No inverse exists */ 
     /* Ensure a positive result */ 
     if (iter < 0) 
      inv = v - u1; 
     else 
      inv = u1; 
     return inv; 
}