ฉันสนใจที่จะสร้างแอพเล็ก ๆ สำหรับใช้ส่วนตัวที่จะเข้ารหัสและถอดรหัสข้อมูลทางฝั่งไคลเอ็นต์โดยใช้ JavaScript ข้อมูลที่เข้ารหัสจะถูกเก็บไว้ในฐานข้อมูลบนเซิร์ฟเวอร์ แต่จะไม่ถอดรหัสรุ่น

ไม่จำเป็นต้องมีความปลอดภัยสูง แต่ฉันต้องการใช้อัลกอริทึมที่ไม่ขาดตอนในขณะนี้

เป็นการดีที่ฉันสามารถทำสิ่งที่ชอบ

var gibberish = encrypt(string, salt, key);

เพื่อสร้างสตริงที่เข้ารหัสและสิ่งที่ต้องการ

var sensical = decrypt(gibberish, key);

เพื่อถอดรหัสในภายหลัง

จนถึงตอนนี้ฉันได้เห็นสิ่งนี้แล้ว: http://bitwiseshiftleft.github.io/sjcl/

ห้องสมุดอื่น ๆ ที่ฉันควรดู?

วิธีการเกี่ยวกับCryptoJS ?

มันเป็นไลบรารี่เข้ารหัสที่มีความสามารถมากมาย มันใช้ hashers, HMAC, PBKDF2 และยันต์ ในกรณีนี้เลขศูนย์คือสิ่งที่คุณต้องการ ตรวจสอบการเริ่มต้นอย่างรวดเร็วในหน้าแรกของโครงการ

คุณสามารถทำอะไรบางอย่างกับ AES:

<script src="http://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>

สำหรับความปลอดภัยในขณะที่อัลกอริทึมการเขียนของฉัน AES คิดว่าจะไม่แตกสลาย

แก้ไข:

ดูเหมือนว่า URL ออนไลน์ไม่ทำงานและคุณสามารถใช้ไฟล์ที่ดาวน์โหลดมาเพื่อเข้ารหัสจากลิงค์ที่ระบุด้านล่าง & วางไฟล์ที่เกี่ยวข้องในโฟลเดอร์รูทของแอปพลิเคชัน

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

หรือใช้ CDN อื่น ๆ เช่นhttps://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.1.2/components/aes-min.js

ฉันสร้างข้อความเข้ารหัส / ถอดรหัสที่ไม่ปลอดภัย แต่ใช้งานง่าย ไม่มีการอ้างอิงกับไลบรารีภายนอกใด ๆ

นี่คือฟังก์ชั่น

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('');
}

และคุณสามารถใช้พวกเขาดังต่อไปนี้:

// 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'

คำตอบที่มีอยู่ซึ่งใช้ประโยชน์จาก SJCL, CryptoJS และ / หรือ WebCrypto ไม่จำเป็นต้องผิดแต่คำตอบนั้นไม่ปลอดภัยเท่าที่คุณสงสัย โดยทั่วไปคุณต้องการที่จะใช้ libsodium ก่อนอื่นฉันจะอธิบายว่าทำไมจึงเป็นเช่นนั้น

ทำไมไม่ใช้ SJCL, CryptoJS, WebCrypto เป็นต้น?

คำตอบสั้น ๆ :เพื่อให้การเข้ารหัสของคุณปลอดภัยจริง ๆ ห้องสมุดเหล่านี้คาดหวังว่าคุณจะมีตัวเลือกมากเกินไปเช่นโหมดการเข้ารหัสบล็อก (CBC, CTR, GCM ถ้าคุณไม่สามารถบอกได้ว่าหนึ่งในสามที่ฉันเพิ่งระบุไว้นั้นปลอดภัย ใช้และภายใต้ข้อ จำกัด คุณไม่ควรรับภาระกับตัวเลือกประเภทนี้เลย )

นอกจากตำแหน่งงานของคุณจะเป็นวิศวกรการเข้ารหัสอัตราต่อรองจะซ้อนกับคุณในการใช้งานอย่างปลอดภัย

ทำไมต้องหลีกเลี่ยง CryptoJS

CryptoJS นำเสนอการสร้างบล็อกจำนวนหนึ่งและคาดว่าคุณจะรู้วิธีใช้อย่างปลอดภัย มันเริ่มต้นที่โหมด CBC ( เก็บถาวร )

เหตุใดโหมด CBC จึงไม่ดี

อ่านบทความนี้เกี่ยวกับช่องโหว่ AES-CBC

ทำไมต้องหลีกเลี่ยง WebCrypto

WebCrypto เป็นมาตรฐานที่ได้รับการออกแบบโดยคณะกรรมการเพื่อจุดประสงค์ที่ตั้งฉากกับวิศวกรรมการเข้ารหัส โดยเฉพาะWebCrypto ถูกหมายถึงการเปลี่ยนแฟลช, ไม่ให้ความปลอดภัย

ทำไมต้องหลีกเลี่ยง SJCL

API สาธารณะและเอกสารของ SJCL ขอให้ผู้ใช้เข้ารหัสข้อมูลด้วยรหัสผ่านที่มนุษย์จำได้ นี่เป็นสิ่งที่คุณไม่ค่อยอยากทำในโลกแห่งความเป็นจริง

นอกจากนี้: PBKDF2 เริ่มต้นนับรอบของมันคือประมาณ86 ครั้งที่มีขนาดเล็กที่สุดเท่าที่คุณอยากให้มันเป็น AES-128-CCM น่าจะใช้ได้

จากสามตัวเลือกข้างต้น SJCL มีโอกาสน้อยที่จะจบด้วยน้ำตา แต่มีตัวเลือกที่ดีกว่า

ทำไม Libsodium ถึงดีกว่า?

คุณไม่จำเป็นต้องเลือกระหว่างเมนูของโหมดตัวเลขฟังก์ชันแฮชและตัวเลือกที่ไม่มีความจำเป็นอื่น ๆ คุณจะไม่เสี่ยงกวดขันขึ้นพารามิเตอร์ของคุณและลบการรักษาความปลอดภัยทั้งหมดออกจากโพรโทคอของคุณ

แต่libsodiumให้ตัวเลือกที่เรียบง่ายแก่คุณเพื่อความปลอดภัยสูงสุดและ API ที่เรียบง่าย

• crypto_box()/ crypto_box_open()เสนอการเข้ารหัสคีย์สาธารณะที่มีการรับรองความถูกต้อง
  • อัลกอริทึมที่เป็นปัญหาประกอบด้วย X25519 (ECDH over Curve25519) และ XSalsa20-Poly1305 แต่คุณไม่จำเป็นต้องรู้
• crypto_secretbox()/ crypto_secretbox_open()เสนอการเข้ารหัสที่รับรองความถูกต้องของคีย์ที่ใช้ร่วมกัน
  • อัลกอริทึมที่เป็นปัญหาคือ XSalsa20-Poly1305 แต่คุณไม่จำเป็นต้องรู้ / ดูแล

นอกจากนี้ libsodium มีการผูกไว้ในภาษาการเขียนโปรแกรมยอดนิยมหลายสิบภาษาดังนั้นจึงเป็นไปได้มากที่ libsodium จะทำงานเมื่อพยายามทำงานร่วมกับสแต็คการเขียนโปรแกรมอื่น นอกจากนี้ libsodium มีแนวโน้มที่จะเร็วมากโดยไม่ลดทอนความปลอดภัย

วิธีใช้ Libsodium ใน JavaScript

ก่อนอื่นคุณต้องตัดสินใจเลือกสิ่งหนึ่ง:

1. คุณเพียงแค่ต้องการเข้ารหัส / ถอดรหัสข้อมูล (และอาจจะยังคงใช้ข้อความธรรมดาในการสืบค้นฐานข้อมูลอย่างปลอดภัย) และไม่ต้องกังวลกับรายละเอียด? หรือ...
2. คุณจำเป็นต้องใช้โปรโตคอลเฉพาะหรือไม่?

หากคุณเลือกตัวเลือกแรก , รับCipherSweet.js

เอกสารที่ได้คือพร้อมใช้งานออนไลน์ EncryptedFieldเพียงพอสำหรับกรณีการใช้งานส่วนใหญ่ แต่EncryptedRowและEncryptedMultiRowsAPI อาจง่ายกว่าถ้าคุณมีฟิลด์ที่แตกต่างกันจำนวนมากที่คุณต้องการเข้ารหัส

ด้วย CipherSweet คุณไม่จำเป็นต้องรู้เลยว่า nonce / IV คือการใช้อย่างปลอดภัย

นอกจากนี้วิธีนี้จะจัดการint/ floatเข้ารหัสโดยไม่รั่วไหลข้อเท็จจริงเกี่ยวกับเนื้อหาผ่านขนาด ciphertext

มิฉะนั้นคุณจะต้องการโซเดียมบวก ,ซึ่งเป็นส่วนหน้าใช้งานง่ายเพื่อห่อ libsodium ต่างๆ Sodium-Plus ช่วยให้คุณสามารถเขียนรหัส, แบบอะซิงโครนัส, ข้ามแพลตฟอร์มที่ง่ายต่อการตรวจสอบและเหตุผลเกี่ยวกับ

หากต้องการติดตั้ง sodium-plus เพียงรัน ...

npm install sodium-plus

ขณะนี้ไม่มี CDN สาธารณะสำหรับการสนับสนุนเบราว์เซอร์ จะมีการเปลี่ยนแปลงในไม่ช้า อย่างไรก็ตามคุณสามารถคว้าsodium-plus.min.jsจากรุ่นล่าสุด Githubถ้าคุณต้องการมัน

const { SodiumPlus } = require('sodium-plus');
let sodium;

(async function () {
    if (!sodium) sodium = await SodiumPlus.auto();
    let plaintext = 'Your message goes here';
    let key = await sodium.crypto_secretbox_keygen();
    let nonce = await sodium.randombytes_buf(24);
    let ciphertext = await sodium.crypto_secretbox(
        plaintext,
        nonce,
        key    
    );
    console.log(ciphertext.toString('hex'));

    let decrypted = await sodium.crypto_secretbox_open(
        ciphertext,
        nonce,
        key
    );

    console.log(decrypted.toString());
})();

เอกสารสำหรับโซเดียมบวกมีอยู่ใน Github

หากคุณต้องการบทช่วยสอนทีละขั้นตอนบทความ dev.to นี้มีสิ่งที่คุณกำลังมองหา

เบราว์เซอร์สมัยใหม่รองรับcrypto.subtleAPI ซึ่งมีฟังก์ชันการเข้ารหัสและถอดรหัสดั้งเดิม (async ไม่น้อยกว่า) โดยใช้วิธีใดวิธีหนึ่งต่อไปนี้: AES-CBC, AES-CTR, AES-GCM หรือ RSA-OAEP

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

ก่อน implementying ใด ๆ นี้โปรดดูคำตอบของสกอตต์ Arciszewski

ฉันต้องการให้คุณระมัดระวังในสิ่งที่ฉันจะแบ่งปันเนื่องจากฉันไม่มีความรู้ด้านความปลอดภัย (มีโอกาสสูงที่ฉันใช้ API ด้านล่างผิด) ดังนั้นฉันจึงยินดีเป็นอย่างยิ่งที่จะอัปเดตคำตอบนี้ ด้วยความช่วยเหลือของชุมชน

ดังที่ @richardtallent พูดถึงในคำตอบของเขามีการสนับสนุน Web Crypto API ดังนั้นตัวอย่างนี้ใช้มาตรฐาน ขณะที่เขียนนี้มีความเป็น95.88% ของการสนับสนุนเบราว์เซอร์ทั่วโลก

ฉันจะแบ่งปันตัวอย่างโดยใช้ Web Crypto API

ก่อนที่เราจะดำเนินการต่อไปโปรดทราบ (การอ้างอิงจาก MDN ):

API นี้มีการเข้ารหัสดั้งเดิมระดับต่ำจำนวนหนึ่ง มันง่ายมากที่จะผิดพวกเขาและข้อผิดพลาดที่เกี่ยวข้องสามารถที่ลึกซึ้งมาก

แม้สมมติว่าคุณใช้ฟังก์ชั่นการเข้ารหัสลับพื้นฐานอย่างถูกต้องการจัดการคีย์ที่ปลอดภัยและการออกแบบระบบความปลอดภัยโดยรวมนั้นทำได้ยากมากและเป็นโดเมนของผู้เชี่ยวชาญด้านความปลอดภัยที่เชี่ยวชาญ

ข้อผิดพลาดในการออกแบบและติดตั้งระบบรักษาความปลอดภัยสามารถทำให้ระบบรักษาความปลอดภัยไม่ได้ผลอย่างสมบูรณ์

หากคุณไม่แน่ใจว่าคุณรู้ว่ากำลังทำอะไรอยู่คุณอาจไม่ควรใช้ APIนี้

ฉันเคารพความปลอดภัยเป็นอย่างมากและฉันยังเสริมส่วนเพิ่มเติมจาก MDN ... คุณได้รับการเตือน

ตอนนี้ให้เป็นตัวอย่างจริง ...

JSFiddle:

พบได้ที่นี่: https://jsfiddle.net/superjose/rm4e0gqa/5/

บันทึก:

หมายเหตุการใช้awaitคำหลัก ใช้ภายในasyncฟังก์ชั่นหรือการใช้งานและ.then().catch()

สร้างกุญแจ:

// 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.

การเข้ารหัสลับ:

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

ถอดรหัส

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

การแปลง ArrayBuffer ไปมาจากสตริง (เสร็จสิ้นใน 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;
  }

คุณสามารถหาตัวอย่างเพิ่มเติมได้ที่นี่ (ฉันไม่ใช่เจ้าของ): // https://github.com/diafygi/webcrypto-examples

CryptoJS ไม่ได้รับการสนับสนุนอีกต่อไป หากคุณต้องการใช้งานต่อไปคุณสามารถเปลี่ยนไปใช้ URL นี้:

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

ใช้SimpleCrypto

ใช้การเข้ารหัส () และถอดรหัส ()

หากต้องการใช้ SimpleCrypto ก่อนอื่นให้สร้างอินสแตนซ์ SimpleCrypto ด้วยรหัสลับ (รหัสผ่าน) ต้องกำหนดพารามิเตอร์คีย์ลับเมื่อสร้างอินสแตนซ์ SimpleCrypto

ในการเข้ารหัสและถอดรหัสข้อมูลเพียงใช้การเข้ารหัส () และถอดรหัส () ฟังก์ชั่นจากอินสแตนซ์ สิ่งนี้จะใช้อัลกอริทึมการเข้ารหัส AES-CBC

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.");

ฟังก์ชั่นที่เรียบง่าย

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