JavaScript-tekenreeksversleuteling en -ontsleuteling?

 var encrypted = CryptoJS.AES.encrypt("Message", "Secret Passphrase");
//U2FsdGVkX18ZUVvShFSES21qHsQEqZXMxQ9zgHy+bu0=
var decrypted = CryptoJS.AES.decrypt(encrypted, "Secret Passphrase");
//4d657373616765
document.getElementById("demo1").innerHTML = encrypted;
document.getElementById("demo2").innerHTML = decrypted;
document.getElementById("demo3").innerHTML = decrypted.toString(CryptoJS.enc.Utf8);

Full working sample actually is:
    <script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.1.2/rollups/aes.js" integrity="sha256-/H4YS+7aYb9kJ5OKhFYPUjSJdrtV6AeyJOtTkw6X72o=" crossorigin="anonymous"></script>
<br><br>
<label>encrypted</label>
<div id="demo1"></div>
<br>
<label>decrypted</label>
<div id="demo2"></div>
<br>
<label>Actual Message</label>
<div id="demo3"></div>

Antwoord 2, autoriteit 42%

Hoe zit het met CryptoJS?

Het is een solide cryptobibliotheek, met veel functionaliteit. Het implementeert hashers, HMAC, PBKDF2 en ciphers. In dit geval zijn cijfers wat je nodig hebt. Bekijk de snelstartgids op de startpagina van het project.

Je zou zoiets met de AES kunnen doen:

<script src="https://crypto-js.googlecode.com/svn/tags/3.1.2/build/rollups/aes.js"></script>
<script>
    var encryptedAES = CryptoJS.AES.encrypt("Message", "My Secret Passphrase");
    var decryptedBytes = CryptoJS.AES.decrypt(encryptedAES, "My Secret Passphrase");
    var plaintext = decryptedBytes.toString(CryptoJS.enc.Utf8);
</script>

Wat betreft de beveiliging, op het moment dat ik dit schrijf, wordt aangenomen dat het AES-algoritme ononderbroken is

Bewerken :

Het lijkt erop dat de online URL niet werkt & u kunt de gedownloade bestanden gebruiken voor codering van de onderstaande link & plaats de respectievelijke bestanden in uw hoofdmap van de toepassing.

https://code.google.com/archive/p/crypto- js/downloads

of andere CDN’s gebruikt, zoals https ://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.1.2/components/aes-min.js

Antwoord 3, autoriteit 36%

Ik heb een onveilig maar eenvoudig hulpprogramma voor tekstversleuteling/ontcijfering gemaakt. Geen afhankelijkheden met een externe bibliotheek.

Dit zijn de functies

const cipher = salt => {
    const textToChars = text => text.split('').map(c => c.charCodeAt(0));
    const byteHex = n => ("0" + Number(n).toString(16)).substr(-2);
    const applySaltToChar = code => textToChars(salt).reduce((a,b) => a ^ b, code);
    return text => text.split('')
        .map(textToChars)
        .map(applySaltToChar)
        .map(byteHex)
        .join('');
}
const decipher = salt => {
    const textToChars = text => text.split('').map(c => c.charCodeAt(0));
    const applySaltToChar = code => textToChars(salt).reduce((a,b) => a ^ b, code);
    return encoded => encoded.match(/.{1,2}/g)
        .map(hex => parseInt(hex, 16))
        .map(applySaltToChar)
        .map(charCode => String.fromCharCode(charCode))
        .join('');
}

En je kunt ze als volgt gebruiken:

// To create a cipher
const myCipher = cipher('mySecretSalt')
//Then cipher any text:
myCipher('the secret string')   // --> "7c606d287b6d6b7a6d7c287b7c7a61666f"
//To decipher, you need to create a decipher and use it:
const myDecipher = decipher('mySecretSalt')
myDecipher("7c606d287b6d6b7a6d7c287b7c7a61666f")    // --> 'the secret string'

Antwoord 4, autoriteit 11%

Moderne browsers ondersteunen nu de crypto.subtle API, die native coderings- en decoderingsfuncties biedt (niet minder async!) met behulp van een van deze methoden: AES-CBC, AES-CTR, AES-GCM , of RSA-OAEP.

https://www.w3.org/TR/WebCryptoAPI/#dfn- cryptografie

Antwoord 5, autoriteit 6%

Deze code is gebaseerd op het antwoord van @Jorgeblom hierboven.

@Jorgeblom mijn man, dat is een fantastische kleine crypto-lib: D
Ik raak het een beetje aan omdat ik het niet leuk vond dat ik het zout moest toewijzen en het opnieuw moest noemen, maar over het algemeen is mijn behoefte absoluut perfect.

const crypt = (salt, text) => {
  const textToChars = (text) => text.split("").map((c) => c.charCodeAt(0));
  const byteHex = (n) => ("0" + Number(n).toString(16)).substr(-2);
  const applySaltToChar = (code) => textToChars(salt).reduce((a, b) => a ^ b, code);
  return text
    .split("")
    .map(textToChars)
    .map(applySaltToChar)
    .map(byteHex)
    .join("");
};
const decrypt = (salt, encoded) => {
  const textToChars = (text) => text.split("").map((c) => c.charCodeAt(0));
  const applySaltToChar = (code) => textToChars(salt).reduce((a, b) => a ^ b, code);
  return encoded
    .match(/.{1,2}/g)
    .map((hex) => parseInt(hex, 16))
    .map(applySaltToChar)
    .map((charCode) => String.fromCharCode(charCode))
    .join("");
};

En jij gebruikt het

// encrypting
const encrypted_text = crypt("salt", "Hello"); // -> 426f666665
// decrypting
const decrypted_string = decrypt("salt", "426f666665"); // -> Hello

Antwoord 6, autoriteit 4%

Bekijk het antwoord van Scott Arciszewski voordat u dit implementeert.

Ik wil dat je heel voorzichtig bent met wat ik ga delen, aangezien ik weinig tot geen beveiligingskennis heb (de kans is groot dat ik de onderstaande API misbruik), dus ik zou meer dan welkom zijn om dit antwoord bij te werken met de hulp van de community.

Zoals @richardtallent al zei in zijn antwoord, is er ondersteuning voor de Web Crypto API, dus in dit voorbeeld wordt de standaard gebruikt. Op het moment van schrijven is er een 95,88% van de wereldwijde browserondersteuning.

Ik ga een voorbeeld delen met behulp van de Web Crypto API

Voordat we verder gaan, let op (citeren van MDN):

Deze API biedt een aantal cryptografische primitieven op laag niveau. Het is heel gemakkelijk om ze te misbruiken, en de valkuilen kunnen heel subtiel zijn.

Zelfs als u de cryptografische basisfuncties correct gebruikt, zijn veilig sleutelbeheer en het algehele ontwerp van het beveiligingssysteem extreem moeilijk om goed te krijgen en zijn ze over het algemeen het domein van gespecialiseerde beveiligingsexperts.

Fouten in het ontwerp en de implementatie van het beveiligingssysteem kunnen de beveiliging van het systeem volledig ineffectief maken.

Als u niet zeker weet wat u doet, moet u deze API waarschijnlijk niet gebruiken.

Ik heb veel respect voor beveiliging, en ik heb zelfs extra delen van MDN vetgedrukt… Je bent gewaarschuwd

Nu, naar het werkelijke voorbeeld…

JSFiddle:

Hier gevonden: https://jsfiddle.net/superjose/rm4e0gqa/5/

Opmerking:

Let op het gebruik van await trefwoorden. Gebruik het in een async-functie of gebruik .then() en .catch().

Genereer de sleutel:

// https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey
// https://developer.mozilla.org/en-US/docs/Web/API/RsaHashedKeyGenParams
// https://github.com/diafygi/webcrypto-examples#rsa-oaep---generatekey
    const stringToEncrypt = 'https://localhost:3001';
    // https://github.com/diafygi/webcrypto-examples#rsa-oaep---generatekey
    // The resultant publicKey will be used to encrypt
    // and the privateKey will be used to decrypt. 
    // Note: This will generate new keys each time, you must store both of them in order for 
    // you to keep encrypting and decrypting.
    //
    // I warn you that storing them in the localStorage may be a bad idea, and it gets out of the scope
    // of this post. 
    const key = await crypto.subtle.generateKey({
      name: 'RSA-OAEP',
      modulusLength: 4096,
      publicExponent:  new Uint8Array([0x01, 0x00, 0x01]),
      hash: {name: 'SHA-512'},
    }, true,
    // This depends a lot on the algorithm used
    // Go to https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto
    // and scroll down to see the table. Since we're using RSA-OAEP we have encrypt and decrypt available
    ['encrypt', 'decrypt']);
    // key will yield a key.publicKey and key.privateKey property.

Versleutelen:

    const encryptedUri = await crypto.subtle.encrypt({
      name: 'RSA-OAEP'
    }, key.publicKey, stringToArrayBuffer(stringToEncrypt))
    console.log('The encrypted string is', encryptedUri);

Decoderen

   const msg = await  crypto.subtle.decrypt({
      name: 'RSA-OAEP',
    }, key.privateKey, encryptedUri);
    console.log(`Derypted Uri is ${arrayBufferToString(msg)}`)

ArrayBuffer heen en weer converteren vanuit String (Gereed in TypeScript):

  private arrayBufferToString(buff: ArrayBuffer) {
    return String.fromCharCode.apply(null, new Uint16Array(buff) as unknown as number[]);
  }
  private stringToArrayBuffer(str: string) {
    const buff = new ArrayBuffer(str.length*2) // Because there are 2 bytes for each char.
    const buffView = new Uint16Array(buff);
    for(let i = 0, strLen = str.length; i < strLen; i++) {
      buffView[i] = str.charCodeAt(i);
    }
    return buff;
  }

Je kunt hier meer voorbeelden vinden (ik ben niet de eigenaar):
// https://github.com/diafygi/webcrypto-examples

Antwoord 7, autoriteit 2%

CryptoJS wordt niet langer ondersteund. Als u het wilt blijven gebruiken, kunt u overschakelen naar deze url:

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.1.2/rollups/aes.js"></script>

Antwoord 8, autoriteit 2%

crypt.subtle AES-GCM, op ​​zichzelf staand, getest:

async function aesGcmEncrypt(plaintext, password)
async function aesGcmDecrypt(ciphertext, password) 

https://gist.github.com/chrisveness/43bcda93af9f646d083fad678071b90a

Antwoord 9, autoriteit 2%

je kunt die functie gebruiken, het is zo gemakkelijk de eerste voor codering, dus je roept de functie aan en verzendt de tekst die je wilt coderen en neemt het resultaat van de encryptWithAES-functie en stuurt het om te decoderen Functie als volgt:

const CryptoJS = require("crypto-js");
   //The Function Below To Encrypt Text
   const encryptWithAES = (text) => {
      const passphrase = "My Secret Passphrase";
      return CryptoJS.AES.encrypt(text, passphrase).toString();
    };
    //The Function Below To Decrypt Text
    const decryptWithAES = (ciphertext) => {
      const passphrase = "My Secret Passphrase";
      const bytes = CryptoJS.AES.decrypt(ciphertext, passphrase);
      const originalText = bytes.toString(CryptoJS.enc.Utf8);
      return originalText;
    };
  let encryptText = encryptWithAES("YAZAN"); 
  //EncryptedText==>  //U2FsdGVkX19GgWeS66m0xxRUVxfpI60uVkWRedyU15I= 
  let decryptText = decryptWithAES(encryptText);
  //decryptText==>  //YAZAN 

Antwoord 10

Gebruik SimpleCrypto

Encrypt() en decrypt() gebruiken

Als u SimpleCrypto wilt gebruiken, maakt u eerst een SimpleCrypto-instantie met a
geheime sleutel (wachtwoord). Geheime sleutelparameter MOET worden gedefinieerd wanneer:
een SimpleCrypto-instantie maken.

Om gegevens te coderen en te decoderen, gebruikt u eenvoudig encrypt() en decrypt()
functie vanuit een instantie. Dit maakt gebruik van het AES-CBC-coderingsalgoritme.

var _secretKey = "some-unique-key";
var simpleCrypto = new SimpleCrypto(_secretKey);
var plainText = "Hello World!";
var chiperText = simpleCrypto.encrypt(plainText);
console.log("Encryption process...");
console.log("Plain Text    : " + plainText);
console.log("Cipher Text   : " + cipherText);
var decipherText = simpleCrypto.decrypt(cipherText);
console.log("... and then decryption...");
console.log("Decipher Text : " + decipherText);
console.log("... done.");

Antwoord 11

Eenvoudige functies,

function Encrypt(value) 
{
  var result="";
  for(i=0;i<value.length;i++)
  {
    if(i<value.length-1)
    {
        result+=value.charCodeAt(i)+10;
        result+="-";
    }
    else
    {
        result+=value.charCodeAt(i)+10;
    }
  }
  return result;
}
function Decrypt(value)
{
  var result="";
  var array = value.split("-");
  for(i=0;i<array.length;i++)
  {
    result+=String.fromCharCode(array[i]-10);
  }
  return result;
}