RSA-Verschlüsselung/Entschlüsselung kompatibel mit Javascript und PHP

Question

Ich möchte in Javascript verschlüsseln und entschlüsseln dann in PHP. Es gibt RSA-Implementierungen für Javascript und PHP, aber sie sind nicht kompatibel. Ich kann in PHP nicht richtig entschlüsseln, was ich mit Javascript verschlüsselt habe.

Kennt jemand eine Bibliothek/einen Code, der sowohl mit Javascript als auch mit PHP funktioniert?

Danke.

Answer 1

Wenn Sie Ihren Server für die Verwendung von SSL eingerichtet haben, können Sie die Übertragung über Ajax mit https verschlüsseln. Das ist wahrscheinlich der beste Weg, um Daten zwischen Javascript und PHP zu verschlüsseln. Wenn Sie es selbst machen wollen, gibt es eine große Chance, dass Sie irgendwo vermasseln und das System wird nicht sicher sein.

Google bei der Einrichtung von https für Ihren Server.

Answer 2

Ich nehme an, Sie haben einen gültigen Grund, dies zu tun, außer https selbst, also würde ich sagen, wenn Sie sich an die Standards halten, sollten Sie in der Lage sein, mit jeder Technologie zu entschlüsseln, die diese Standards unterstützt: dh es sollte Arbeit

Zum Beispiel, wenn Sie Ihre Daten im PKCS # 7-Format verschlüsseln, stellen Sie sicher, dass Ihre PHP-Bibliothek weiß, dass die Eingabedaten PKCS # 7 ist.

Vergewissern Sie sich auch, dass Ihr Verschlüsselungsschlüssel nicht zwischen Server und Client verschlüsselt ist. Haben Sie versucht, Ihre Daten mit Ihrer Javascript-Bibliothek zu entschlüsseln?

Hope this helfen ...

Answer 3

Vielleicht können Sie helfen, indem Sie den Code setzen Sie für beide js und PHP.

Vielleicht könnten Sie auch genauer, warum Sie js und php verwenden müssen. Vielleicht könnten Sie nur PHP und AJAX verwenden (um die gleiche PHP-Funktion abzufragen), wo Sie js verwendet haben.

Answer 4

Hier ist eine JavaScript RSA Verschlüsselungsbibliothek ist: http://www.ohdave.com/rsa/

Und ich denke, Sie so etwas wie diese Klasse verwenden könnte den erzeugten verschlüsselten Zeichenfolge zu entschlüsseln - http://www.phpclasses.org/browse/package/4121.html

Lassen Sie mich wissen, wenn Sie diese Arbeit gemeinsam verwalten bekommen, wie ich selbst in dieses Thema schaue (ich fand diesen Beitrag tatsächlich selbst nach dieser Antwort: P).

Edit: Hören Sie, ich habe festgestellt, das auch - http://www.sematopia.com/?p=275 - zu den beiden vorangegangenen als auch ...

Answer 5

Ich bin nicht einer meiner eigenes Horn tuten, aber ich habe ein Projekt, bei github.com Zusammenhang scheint das wird diese Funktionalität ausführen.

Ein privater Schlüssel wird auf dem Server generiert, ein öffentlicher Schlüssel und ein PKCS # 7-Zertifikat werden ebenfalls vom privaten Schlüssel abgeleitet. Der öffentliche Schlüssel wird an den Client gesendet. Zu diesem Zeitpunkt wird jedes mit dem angegebenen Formular verknüpfte Formularelement verschlüsselt, bevor es an den Server gesendet wird.

Es ist zu 100% OpenSSL-kompatibel, da es die OpenSSL-Erweiterung von PHP zum Generieren, Verschlüsseln und Entschlüsseln von Daten verwendet.

https://github.com/jas-/jQuery.pidCrypt/

Dieses Projekt ist nicht so sicher wie PGP, da die JavaScript nicht unterzeichnen und E-Mails verschlüsseln, bis die Formulardaten an den Server gesendet wird, aber die Formulardaten, die verschlüsselt werden soll und oder signiert werden verschlüsselt Verwenden der RSA Public Key-Verschlüsselung vor dem Senden an den Server.

Wieder ist das Projekt nicht vollständig in Bezug auf die Authentifizierung und E-Mail-Signierung, aber für normale Form der Verschlüsselung mit einem öffentlichen Schlüssel funktioniert es sehr gut.

Answer 6

Versuchen Sie das folgende einfache Beispiel.

Es ist eine Open-Source-Bibliothek mit Hilfe von Javascript https://github.com/ziyan/javascript-rsa

HTML/javascript:

<script language="JavaScript" type="text/javascript" src="jsbn.js"></script> 
<script language="JavaScript" type="text/javascript" src="rsa.js"></script> 

<script language="JavaScript"> 

    function encryptData(){ 

     //Don't forget to escape the lines: 
     var pem="-----BEGIN PUBLIC KEY-----\ 
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDfmlc2EgrdhvakQApmLCDOgP0n\ 
NERInBheMh7J/r5aU8PUAIpGXET/8+kOGI1dSYjoux80AuHvkWp1EeHfMwC/SZ9t\ 
6rF4sYqV5Lj9t32ELbh2VNbE/7QEVZnXRi5GdhozBZtS1gJHM2/Q+iToyh5dfTaA\ 
U8bTnLEPMNC1h3qcUQIDAQAB\ 
-----END PUBLIC KEY-----"; 

     var key = RSA.getPublicKey(pem); 

     element=document.getElementById('password'); 
     element.value=RSA.encrypt(element.value, key); 
    } 
</script> 

<form method='POST' id='txtAuth' onsubmit='encryptData()'> 
    <input type='text' name='username'/> 
    <input type='password' name='password' id='password' placeholder="password"/> 
    <input name='submit' type='submit' value='Submit'> 
</form> 

PHP:

<?php 

if (isset($_POST['password'])) { 

    //Load private key: 
    $private = "-----BEGIN RSA PRIVATE KEY----- 
    MIICXAIBAAKBgQDfmlc2EgrdhvakQApmLCDOgP0nNERInBheMh7J/r5aU8PUAIpG 
    XET/8+kOGI1dSYjoux80AuHvkWp1EeHfMwC/SZ9t6rF4sYqV5Lj9t32ELbh2VNbE 
    /7QEVZnXRi5GdhozBZtS1gJHM2/Q+iToyh5dfTaAU8bTnLEPMNC1h3qcUQIDAQAB 
    AoGAcbh6UFqewgnpGKIlZ89bpAsANVckv1T8I7QT6qGvyBrABut7Z8t3oEE5r1yX 
    UPGcOtkoRniM1h276ex9VtoGr09sUn7duoLiEsp8aip7p7SB3X6XXWJ9K733co6C 
    dpXotfO0zMnv8l3O9h4pHrrBkmWDBEKbUeuE9Zz7uy6mFAECQQDygylLjzX+2rvm 
    FYd5ejSaLEeK17AiuT29LNPRHWLu6a0zl923299FCyHLasFgbeuLRCW0LMCs2SKE 
    Y+cIWMSRAkEA7AnzWjby8j8efjvUwIWh/L5YJyWlSgYKlR0zdgKxxUy9+i1MGRkn 
    m81NLYza4JLvb8/qjUtvw92Zcppxb7E7wQJAIuQWC+X12c30nLzaOfMIIGpgfKxd 
    jhFivZX2f66frkn2fmbKIorCy7c3TIH2gn4uFmJenlaV/ghbe/q3oa7L0QJAFP19 
    ipRAXpKGX6tqbAR2N0emBzUt0btfzYrfPKtYq7b7XfgRQFogT5aeOmLARCBM8qCG 
    tzHyKnTWZH6ff9M/AQJBAIToUPachXPhDyOpDBcBliRNsowZcw4Yln8CnLqgS9H5 
    Ya8iBJilFm2UlcXfpUOk9bhBTbgFp+Bv6BZ2Alag7pY= 
    -----END RSA PRIVATE KEY-----"; 
    if (!$privateKey = openssl_pkey_get_private($private)) die('Loading Private Key failed'); 

    //Decrypt 
    $decrypted_text = ""; 
    if (!openssl_private_decrypt(base64_decode($_POST['password']), $decrypted_text, $privateKey)) die('Failed to decrypt data'); 

    //Decrypted :) 
    var_dump($decrypted_text); 

    //Free key 
    openssl_free_key($privateKey); 
} 
?> 

Viel Spaß!

Answer 7

Ich finde diese Jsencrypt-Bibliothek (http://travistidwell.com/jsencrypt), nach 2 Tagen versuchte ich meine Lösung.

Das einzige Problem, das ich habe, ist, wenn ich einen langen Text sende. Das liegt daran, dass RSA definitionsgemäß Strings begrenzter Länge unterstützt.

https://security.stackexchange.com/questions/33434/rsa-maximum-bytes-to-encrypt-comparison-to-aes-in-terms-of-security/33445#33445

RSA, als 1 von PKCS # definiert, verschlüsselt "Botschaften" von begrenzten Größe. Mit der häufig verwendeten "v1.5 Padding" und einem 2048-Bit-RSA-Schlüssel ist die maximale Größe von Daten, die mit RSA verschlüsselt werden können, 245 Bytes. Nicht mehr.

heißt Wenn ich private_key_bits von 1024 verwenden, kann ich

"José compró en Perú una vieja zampoña. Excusándose, Sofía tiró su whisky al desagüe de la banqueta." 

nichts mehr senden. Wenn ich private_key_bits von 512 verwenden kann ich

"José compró en Perú una vieja zampoña. Excusánd" 

nichts mehr senden.

Auf langen Strings JavaScript-Konsole berichtet: „Nachricht zu lang für RSA“

Dann, wenn Sie Sie müssen lange Strings verschlüsseln komprimieren und teilen Sie sie vor dem Javascript-Verschlüsselung und nach der Entschlüsselung beitreten und auf php dekomprimieren, ich glaube, zlib ist eine gute Lösung für Split/Join, da es auf Javascript und PHP unterstützt wird.

Mein Arbeits Code ist wie folgt:

<?php 
    //------------------------------------------------------------ 
    // Global Settings. 
    //------------------------------------------------------------ 
    ini_set('display_errors', 1); 
    error_reporting(E_ALL); 
    $directorio = "/path/to/key/directory/apache/writable/"; 
    $nombre_base = "llaves_php"; 

    //------------------------------------------------------------ 
    // Initialization. 
    //------------------------------------------------------------ 
    $encabezado_html = ""; 
    $cuerpo_html = ""; 

    //------------------------------------------------------------ 
    // Loading keys 
    //------------------------------------------------------------ 
    list($privateKey, $pubKey) = 
     cargar_llaves_RSA($directorio, $nombre_base); 

    //------------------------------------------------------------ 
    // Form that uses javascript to encrypt data. 
    // (it uses only the public key) 
    //------------------------------------------------------------ 
    $librerias_html = " 
     <script type='text/javascript' 
       src='https://ajax.googleapis.com/ajax/libs/". 
        "jquery/3.2.1/jquery.min.js'></script> 
     <script type='text/javascript' 
       src='lib/jsencrypt.js'></script> 
     "; 

    $pubKey_html = htmlentities($pubKey); 
    $datos_html = " 
     <h2>Cifrando con Javascript</h2> 
     <input type='text' id='mensaje' /> 
     <br /> 
     <button id='ENVIAR'>Enviar</button> 
     <br /> 
     <textarea id='pubkey' style='display: none;'>". 
     $pubKey_html. 
     "</textarea> 
     <script type='text/javascript'> 
      $('#ENVIAR').click(function() { 
       var codificador = new JSEncrypt(); 
       codificador.setKey($('#pubkey').val()); 
       var cifrado = codificador.encrypt($('#mensaje').val()); 
       window.open('?mensaje=' + encodeURIComponent(cifrado) 
          , '_top'); 
      }); 
     </script> 
     "; 

    //------------------------------------------------------------ 
    // Decrypting using php (it uses only the privateKey) 
    //------------------------------------------------------------ 
    if (isset($_REQUEST['mensaje'])) { 
     openssl_private_decrypt(base64_decode($_REQUEST['mensaje']) 
           , $descifrado 
           , $privateKey); 
     $datos_html.= " 
      <h2>Descifrando con PHP</h2> 
      ".$descifrado." 
      "; 
    } 

    //------------------------------------------------------------ 
    // HTML DISPLAY 
    //------------------------------------------------------------ 
    $encabezado_html.= "<title>Receptor de mensaje cifrado</title>" 
        . $librerias_html; 

    $cuerpo_html.= $datos_html; 

    $contenido = "<head>$encabezado_html</head><body>$cuerpo_html</body>"; 
    $contenido = "<html>$contenido</html>"; 
    print $contenido; 

//============================================================ 
//============================================================ 
// Functions 
//============================================================ 
//============================================================ 

    //------------------------------------------------------------ 
    function cargar_llaves_RSA($directorio, $nombre_base) { 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    // PROPÓSITO: Genera o carga desde archivos las llaves RSA 
    // ENTRADAS: 
    // $directorio: Directorio donde se encuentran los archivos. 
    // $nombre_base: Nombre, sin extensión, de los archivos con 
    //    las llaves. 
    // SALIDAS: 
    //------------------------------------------------------------ 
     if ( !file_exists($directorio.$nombre_base.".crt") 
      || !file_exists($directorio.$nombre_base.".pub")) { 
      list($privateKey, $pubKey) = crear_llaves_RSA($directorio.$nombre_base); 
     } else { 
      //------------------------------------------------------------ 
      // CARGA DE LLAVES RSA ARCHIVADAS 
      //------------------------------------------------------------ 
      $privateKey = file_get_contents($directorio.$nombre_base.".crt"); 
     if (!$privKey = openssl_pkey_get_private($privateKey)) 
      die('Loading Private Key failed'); 
      $pubKey = file_get_contents($directorio.$nombre_base.".pub"); 
     } 

    return array($privateKey, $pubKey); 
    } 

    //------------------------------------------------------------ 
    function crear_llaves_RSA($ruta_base) { 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    // PROPÓSITO: 
    // generacion de llaves RSA en php 
    // ENTRADAS: 
    // $ruta_base: Ruta de los archivos a generar sin extensión. 
    // SALIDAS: 
    // Se generarán dos archivos, uno con la llave privada con 
    // extensión .crt, el otro con llave pública con extensión 
    // .pub; la función retorna tanto la llave pública como la 
    // privada en un arreglo. 
    //------------------------------------------------------------ 
     $config = array(
      "private_key_bits" => 1024, 
      "private_key_type" => OPENSSL_KEYTYPE_RSA, 
     ); 

     $llavePrivadaCruda = openssl_pkey_new($config); 
     openssl_pkey_export_to_file($llavePrivadaCruda, $ruta_base.".crt"); 
     $privateKey = file_get_contents($ruta_base.".crt"); 
     openssl_pkey_export($llavePrivadaCruda, $privKey); 

     $pubKeyData = openssl_pkey_get_details($llavePrivadaCruda); 
     $pubKey = $pubKeyData["key"]; 
     file_put_contents($ruta_base.".pub", $pubKey); 
     openssl_free_key($llavePrivadaCruda); 

    return array($privateKey, $pubKey); 
    } 

    //------------------------------------------------------------ 
    function Mostrar($valor) { 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    // PROPÓSITO: Genera el código HTML para presentar una 
    // variable embebida en la página. 
    // ENTRADAS: 
    // $valor: el valor a presentar. 
    // SALIDAS: código html que permite visualizar la variable. 
    //------------------------------------------------------------ 
     $retorno = htmlentities(stripslashes(var_export($valor, true))); 
     $retorno = "<pre>$retorno</pre>"; 
     return $retorno; 
    } 

?> 

Verzeichnisbaum muss wie folgt aussieht:

├── script.php 
└── lib 
    └── jsencrypt.js 

und ein Verzeichnis beschreibbar von PHP außerhalb der öffentlichen Zone namens

/path/to/key/directory/apache/writable/ 

---