RSA de chiffrement/déchiffrement compatible avec Javascript et PHP

Voici un JavaScript, le cryptage RSA, de la bibliothèque: http://www.ohdave.com/rsa/

Et je pense que vous pouvez utiliser quelque chose comme cette classe pour décrypter l'généré chaîne cryptée - http://www.phpclasses.org/browse/package/4121.html

Laissez-moi savoir si vous gérez des travaux d'ensemble, comme je le suis moi-même à la recherche dans ce sujet (j'ai en fait trouvé ce post à la recherche de cette réponse moi-même 😛 ) .

Edit: Regardez, j'ai aussi trouvé ceci - http://www.sematopia.com/?p=275 - semble liée aux deux précédentes ainsi...

Si vous configurez votre serveur pour utiliser SSL, alors vous pouvez avoir transmission cryptée via ajax en utilisant le protocole https. C'est probablement la meilleure façon de crypter les données entre le javascript et le php. Si vous voulez le faire vous-même il y a de grande chances que tu vis quelque part, et le système ne sera pas sécurisée.

Google sur comment configurer le protocole https pour votre serveur.

Peut-être que vous pouvez l'aider en mettant le code que vous utilisez pour les js et php.

Aussi, peut-être que vous pourriez être plus précis sur les raisons pour lesquelles vous devez utiliser js et php. Peut-être que vous pourriez utiliser uniquement en php et AJAX (à la requête de la même fonction php) où vous avez été en utilisant js.

Je trouve ce jsencrypt bibliothèque (http://travistidwell.com/jsencrypt), après 2 jours à essayer j'ai eu ma solution.

Le seul problème que j'ai eu c'est quand j'envoie un long texte. C'est parce que RSA, par définition, prend en charge les chaînes de longueur limitée.

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

RSA, tel que défini par PKCS#1, chiffre les "messages" de taille limitée. Avec
couramment utilisées "v1.5 padding" et une définition de 2 048 bits de clé RSA, le maximum
la taille des données qui peuvent être cryptées avec RSA est de 245 octets. Pas plus.

c'est à dire
Si j'utilise private_key_bits de 1024 je peux envoyer

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

rien de plus.
Si j'utilise private_key_bits de 512 je peux envoyer

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

rien de plus.

Sur de longues chaînes de la console JavaScript de rapports: "Message trop long pour le RSA"

Alors si vous souhaitez crypter le long des chaînes, vous devez compresser et de les séparer avant de javascript de chiffrement et après le décryptage rejoindre et à décompresser sur php, je pense que zlib est une bonne solution pour split/join car elle est prise en charge sur le javascript et le php.

Mon code de travail est comme suit:

<?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;
}
?>

Arborescence de répertoire doit ressembler à:

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

et un répertoire accessible en écriture par php à l'extérieur de la zone publique nommé

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

---