crypto es
v2.0.4
Eine Kryptographie -Algorithmenbibliothek, die mit ES6 und Typenkript kompatibel ist
Installation:
yarn add crypto-es
In Node.js -Projekten empfehlen wir Ihnen, die ECMascript -Module für CommonJs zu verwenden:
// package.json
{
"type": "module"
}
Dann können Sie Kryptoes importieren:
import CryptoES from 'crypto-es';
const rst = CryptoES.MD5("Message").toString();
Oder teilweise die Funktion importieren, um das Paketgewicht zu reduzieren:
import { MD5 } from 'crypto-es/lib/md5.js';
const rst = MD5("Message").toString();
Jede Datei in dieser Bibliothek hat jetzt eine eigene .d.ts -Datei, sodass sie teilweise einzelne Algorithmusdateien in TypeScript -Projekten importieren kann.
Genauso wie Cryptojs
MD5
MD5 ist eine weit verbreitete Hash -Funktion. Es wurde in einer Vielzahl von Sicherheitsanwendungen verwendet und wird häufig verwendet, um die Integrität von Dateien zu überprüfen. MD5 ist jedoch nicht kollisionsbeständig und eignet sich nicht für Anwendungen wie SSL -Zertifikate oder digitale Signaturen, die auf dieser Eigenschaft beruhen.
const hash = CryptoES.MD5("Message");
SHA-1
Die SHA -Hash -Funktionen wurden von der National Security Agency (NSA) entworfen. SHA-1 ist am etabliertesten der vorhandenen SHA-Hash-Funktionen und wird in einer Vielzahl von Sicherheitsanwendungen und Protokollen verwendet. Der Kollisionsbeständigkeit von SHA-1 hat sich jedoch geschwächt, da neue Angriffe entdeckt oder verbessert werden.
const hash = CryptoES.SHA1("Message");
SHA-2
SHA-256 ist eine der vier Varianten im SHA-2-Set. Es ist nicht so weit verbreitet wie SHA-1, obwohl es anscheinend eine viel bessere Sicherheit zu bieten scheint.
const hash = CryptoES.SHA256("Message");
SHA-512 ist weitgehend identisch mit SHA-256, arbeitet jedoch eher auf 64-Bit-Wörtern als auf 32.
const hash = CryptoES.SHA512("Message");
Kryptoes unterstützt auch SHA-224 und SHA-384, die weitgehend identische, aber verkürzte Versionen von SHA-256 bzw. SHA-512 sind.
Sha-3
SHA-3 ist der Gewinner eines fünfjährigen Wettbewerbs zur Auswahl eines neuen kryptografischen Hash-Algorithmus, bei dem 64 konkurrierende Designs bewertet wurden.
Hinweis: Ich habe einen Fehler gemacht, als ich diese Implementierung SHA-3 benannte. Es sollte Keccak [C = 2D] heißt. Jede der SHA-3-Funktionen basiert auf einer Instanz des Keccak-Algorithmus, die NIST als Gewinner des SHA-3-Wettbewerbs ausgewählt hat. Diese SHA-3-Funktionen werden jedoch nicht mit Keccak identischem Hashes erzeugen.
const hash = CryptoES.SHA3("Message");
SHA-3 kann so konfiguriert werden, dass Hash-Längen von einem von 224, 256, 384 oder 512 Bits ausgab. Der Standardwert beträgt 512 Bit.
const hash = CryptoES.SHA3("Message", { outputLength: 512 });
const hash = CryptoES.SHA3("Message", { outputLength: 384 });
const hash = CryptoES.SHA3("Message", { outputLength: 256 });
const hash = CryptoES.SHA3("Message", { outputLength: 224 });
RIPEMD-160
const hash = CryptoES.RIPEMD160("Message");
Die Hash -Algorithmen akzeptieren entweder Zeichenfolgen oder Instanzen von Cryptoes.lib.wordarray. Ein WordArray-Objekt repräsentiert ein Array von 32-Bit-Wörtern. Wenn Sie eine Zeichenfolge übergeben, wird sie automatisch in ein als UTF-8 codiertes WordArray konvertiert.
Der Hash, den Sie zurückbekommen, ist noch keine Zeichenfolge. Es ist ein WordArray -Objekt. Wenn Sie ein WordArray -Objekt in einem String -Kontext verwenden, wird es automatisch in eine Hex -Zeichenfolge konvertiert.
const hash = CryptoES.SHA256("Message");
alert(typeof hash); // object
alert(hash); // 2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91
Sie können ein WordArray -Objekt in andere Formate konvertieren, indem Sie explizit die ToString -Methode aufrufen und einen Encoder übergeben.
const hash = CryptoES.SHA256("Message");
alert(hash.toString(CryptoES.enc.Base64)); // L3dmip37+NWEi57rSnFFypTG7ZI25Kdz9tyvpRMrL5E= alert(hash.toString(CryptoES.enc.Latin1)); // /wf��ûøÕ���ëJqEÊ�Æí�6ä§söܯ¥�+/�
alert(hash.toString(CryptoES.enc.Hex)); // 2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91
const sha256 = CryptoES.algo.SHA256.create();
sha256.update("Message Part 1");
sha256.update("Message Part 2");
sha256.update("Message Part 3");
const hash = sha256.finalize();
Die Keyed-Hash-Nachrichtenauthentifizierungscodes (HMAC) ist ein Mechanismus für die Nachrichtenauthentifizierung unter Verwendung kryptografischer Hash-Funktionen.
HMAC kann in Kombination mit jeder iterierten kryptografischen Hash -Funktion verwendet werden.
const hash = CryptoES.HmacMD5("Message", "Secret Passphrase");
const hash = CryptoES.HmacSHA1("Message", "Secret Passphrase");
const hash = CryptoES.HmacSHA256("Message", "Secret Passphrase");
const hash = CryptoES.HmacSHA512("Message", "Secret Passphrase");
const hmac = CryptoES.algo.HMAC.create(CryptoES.algo.SHA256, "Secret Passphrase");
hmac.update("Message Part 1");
hmac.update("Message Part 2");
hmac.update("Message Part 3");
const hash = hmac.finalize();
PBKDF2 ist eine kennwortbasierte wichtige Funktion der Schlüsselableitungen. In vielen Anwendungen der Kryptographie hängt die Benutzersicherheit letztendlich von einem Kennwort ab. Da ein Kennwort normalerweise nicht direkt als kryptografischer Schlüssel verwendet werden kann, ist eine gewisse Verarbeitung erforderlich.
Ein Salz liefert einen großen Satz von Schlüssel für ein bestimmtes Passwort, und eine Iterationszahl erhöht die Kosten für die Herstellung von Schlüssel aus einem Passwort und erhöht auch die Schwierigkeit des Angriffs.
const salt = CryptoES.lib.WordArray.random(128/8);
const key128Bits = CryptoES.PBKDF2("Secret Passphrase", salt, { keySize: 128/32 });
const key256Bits = CryptoES.PBKDF2("Secret Passphrase", salt, { keySize: 256/32 });
const key512Bits = CryptoES.PBKDF2("Secret Passphrase", salt, { keySize: 512/32 });
const key512Bits1000Iterations = CryptoES.PBKDF2("Secret Passphrase", salt, { keySize: 512/32, iterations: 1000 });
AES
Der Advanced Encryption Standard (AES) ist ein US -amerikanischer FIPS -Standard für Informationsverarbeitung (Federal Information Processing). Es wurde nach einem 5-Jahres-Prozess ausgewählt, bei dem 15 konkurrierende Konstruktionen bewertet wurden.
const encrypted = CryptoES.AES.encrypt("Message", "Secret Passphrase");
const decrypted = CryptoES.AES.decrypt(encrypted, "Secret Passphrase");
Cryptoes unterstützt AES-128, AES-192 und AES-256. Es wird die Variante nach der Größe des Schlüssels auswählen, den Sie übergeben. Wenn Sie eine Passphrase verwenden, erzeugt sie einen 256-Bit-Schlüssel.
Des, Triple Des
DES ist ein bisher dominanter Algorithmus für die Verschlüsselung und wurde als offizieller Bundesverarbeitungsstandard (FIPS) veröffentlicht. DES gilt jetzt aufgrund der geringen Schlüsselgröße als unsicher.
const encrypted = CryptoES.DES.encrypt("Message", "Secret Passphrase");
const decrypted = CryptoES.DES.decrypt(encrypted, "Secret Passphrase");
Triple DES wendet DES dreimal für jeden Block an, um die Schlüsselgröße zu erhöhen. Es wird angenommen, dass der Algorithmus in dieser Form sicher ist.
const encrypted = CryptoES.TripleDES.encrypt("Message", "Secret Passphrase");
const decrypted = CryptoES.TripleDES.decrypt(encrypted, "Secret Passphrase");
Kaninchen
Kaninchen ist eine Hochleistungs-Stream-Chiffre und ein Finalist im Estrom-Portfolio. Es ist eines der vier nach einem 3 1/2-Jahres-Verfahren ausgewählten Designs, bei dem 22 Auszeichnungen bewertet wurden.
const encrypted = CryptoES.Rabbit.encrypt("Message", "Secret Passphrase");
const decrypted = CryptoES.Rabbit.decrypt(encrypted, "Secret Passphrase");
RC4, RC4Drop
RC4 ist eine weit verbreitete Stream-Chiffre. Es wird in beliebten Protokollen wie SSL und WEP verwendet. Obwohl die Geschichte des Algorithmus für seine Einfachheit und Geschwindigkeit bemerkenswert ist, schafft es nicht das Vertrauen in seine Sicherheit.
const encrypted = CryptoES.RC4.encrypt("Message", "Secret Passphrase");
const decrypted = CryptoES.RC4.decrypt(encrypted, "Secret Passphrase");
Es wurde festgestellt, dass die ersten Bytes des Tastenams stark nicht zufällig sind und Informationen über den Schlüssel auslaufen. Wir können gegen diesen Angriff verteidigen, indem wir den ersten Teil des Keystreams verwerfen. Dieser modifizierte Algorithmus wird traditionell als RC4-Drop bezeichnet.
Standardmäßig werden 192 Wörter (768 Bytes) fallen gelassen, aber Sie können den Algorithmus so konfigurieren, dass sie eine beliebige Anzahl von Wörtern fallen lassen.
const encrypted = CryptoES.RC4Drop.encrypt("Message", "Secret Passphrase");
const encrypted = CryptoES.RC4Drop.encrypt("Message", "Secret Passphrase", { drop: 3072/4 });
const decrypted = CryptoES.RC4Drop.decrypt(encrypted, "Secret Passphrase", { drop: 3072/4 });
Blowfish
Blowfish ist eine symmetrische Blockausfall, die 1993 von Bruce Schneier entworfen und in vielen Cipher-Suiten und Verschlüsselungsprodukten enthalten ist. Blowfish bietet eine gute Verschlüsselungsrate in der Software, und bisher wurde keine effektive Kryptanalyse festgestellt. Der Advanced Encryption Standard (AES) erhält nun mehr Aufmerksamkeit, und Schneier empfiehlt Twofish für moderne Anwendungen.
Schneier entwarf Blowfish als allgemeiner Algorithmus, der als Alternative zum alternden DES und frei von den Problemen und Einschränkungen bestimmt war, die mit anderen Algorithmen verbunden sind. Zum Zeitpunkt der Zeit, in der Blowfish veröffentlicht wurde, waren viele andere Entwürfe proprietär, von Patenten oder gewerblichen oder staatlichen Geheimnissen belastet. Schneier hat erklärt, dass "Blowfish nicht nicht geeignet ist und in allen Ländern so bleiben wird. Der Algorithmus wird hiermit öffentlich zugänglich gemacht und kann von irgendjemandem frei genutzt werden."
Zu den bemerkenswerten Merkmalen des Designs gehören wichtige S-Boxen und einen hochkomplexen Schlüsselplan.
const ciphertext = CryptoJS.Blowfish.encrypt(message, key, cfg);
const plaintext = CryptoJS.Blowfish.decrypt(ciphertext, key, cfg);
const key = CryptoES.enc.Hex.parse('000102030405060708090a0b0c0d0e0f');
const iv = CryptoES.enc.Hex.parse('101112131415161718191a1b1c1d1e1f');
const encrypted = CryptoES.AES.encrypt("Message", key, { iv: iv });
const encrypted = CryptoES.AES.encrypt("Message", "Secret Passphrase", { mode: CryptoES.mode.CFB, padding: CryptoES.pad.AnsiX923 });
Kryptoes unterstützt die folgenden Modi:
Und Kryptos unterstützt die folgenden Polsterprogramme:
Für die Klartextnachricht akzeptieren die Cipher -Algorithmen entweder Zeichenfolgen oder Instanzen von Cryptoes.lib.wordarray.
Für den Schlüssel wird beim Übergeben einer Saite sie als Passphrase behandelt und verwendet, um einen tatsächlichen Schlüssel und IV abzuleiten. Oder Sie können ein WordArray übergeben, das den tatsächlichen Schlüssel darstellt. Wenn Sie den tatsächlichen Schlüssel übergeben, müssen Sie auch die tatsächliche IV übergeben.
Für den Chiffretext akzeptieren die Chiffre -Algorithmen entweder Zeichenfolgen oder Instanzen von Cryptoes.lib.cipherparams. Ein Cipherparams -Objekt repräsentiert eine Sammlung von Parametern wie IV, ein Salz und den rohen Chiffretext selbst. Wenn Sie eine Zeichenfolge übergeben, wird sie automatisch in ein Cipherparams -Objekt gemäß einer konfigurierbaren Formatstrategie konvertiert.
Der Klartext, den Sie nach der Entschlüsselung zurückbekommen, ist ein WordArray -Objekt. Weitere Informationen finden Sie unter Hashers -Ausgabe.
Der Chiffrikett, den Sie nach der Verschlüsselung zurückbekommen, ist noch keine Zeichenfolge. Es ist ein Cipherparams -Objekt. Mit einem Cipherparams -Objekt Zugriff auf alle während der Verschlüsselung verwendeten Parameter. Wenn Sie ein Cipherparams -Objekt in einem String -Kontext verwenden, wird es automatisch in eine Zeichenfolge gemäß einer Formatstrategie konvertiert. Die Standardeinstellung ist ein openSSL-kompatibler Format.
const encrypted = CryptoES.AES.encrypt("Message", "Secret Passphrase"); alert(encrypted.key); // 74eb593087a982e2a6f5dded54ecd96d1fd0f3d44a58728cdcd40c55227522223
alert(encrypted.iv); // 7781157e2629b094f0e3dd48c4d786115
alert(encrypted.salt); // 7a25f9132ec6a8b34
alert(encrypted.ciphertext); // 73e54154a15d1beeb509d9e12f1e462a0
alert(encrypted); // U2FsdGVkX1+iX5Ey7GqLND5UFUoV0b7rUJ2eEvHkYqA=
Sie können Ihre eigenen Formate definieren, um mit anderen Krypto -Implementierungen kompatibel zu sein. Ein Format ist ein Objekt mit zwei Methoden - Stringify und Parse -, das zwischen Cipherparams -Objekten und Chiffretext -Zeichenfolgen umwandelt.
So schreiben Sie ein JSON -Formatierer:
const JsonFormatter = {
stringify: function (cipherParams) { // create json object with ciphertext
const jsonObj = { ct: cipherParams.ciphertext.toString(CryptoES.enc.Base64) }; // optionally add iv and salt
if (cipherParams.iv) {
jsonObj.iv = cipherParams.iv.toString();
}
if (cipherParams.salt) {
jsonObj.s = cipherParams.salt.toString();
}
// stringify json object
return JSON.stringify(jsonObj);
},
parse: function (jsonStr) { // parse json string
const jsonObj = JSON.parse(jsonStr); // extract ciphertext from json object, and create cipher params object
const cipherParams = CryptoES.lib.CipherParams.create(
{ ciphertext: CryptoES.enc.Base64.parse(jsonObj.ct) },
); // optionally extract iv and salt
if (jsonObj.iv) {
cipherParams.iv = CryptoES.enc.Hex.parse(jsonObj.iv)
}
if (jsonObj.s) {
cipherParams.salt = CryptoES.enc.Hex.parse(jsonObj.s)
}
return cipherParams;
},
};
const encrypted = CryptoES.AES.encrypt(
"Message",
"Secret Passphrase",
{ format: JsonFormatter },
);
alert(encrypted); // {"ct":"tZ4MsEnfbcDOwqau68aOrQ==","iv":"8a8c8fd8fe33743d3638737ea4a00698","s":"ba06373c8f57179c"}
const decrypted = CryptoES.AES.decrypt(
encrypted,
"Secret Passphrase",
{ format: JsonFormatter },
);
alert(decrypted.toString(CryptoES.enc.Utf8)); // Message
const key = CryptoES.enc.Hex.parse('000102030405060708090a0b0c0d0e0f');
const iv = CryptoES.enc.Hex.parse('101112131415161718191a1b1c1d1e1f');
const aesEncryptor = CryptoES.algo.AES.createEncryptor(key, { iv: iv });
const ciphertextPart1 = aesEncryptor.process("Message Part 1");
const ciphertextPart2 = aesEncryptor.process("Message Part 2");
const ciphertextPart3 = aesEncryptor.process("Message Part 3");
const ciphertextPart4 = aesEncryptor.finalize();
const aesDecryptor = CryptoES.algo.AES.createDecryptor(key, { iv: iv });
const plaintextPart1 = aesDecryptor.process(ciphertextPart1);
const plaintextPart2 = aesDecryptor.process(ciphertextPart2);
const plaintextPart3 = aesDecryptor.process(ciphertextPart3);
const plaintextPart4 = aesDecryptor.process(ciphertextPart4);
const plaintextPart5 = aesDecryptor.finalize();
Mit OpenSSL
Mit OpenSSL verschlüsseln:
openssl enc -aes-256-cbc -in infile -out outfile -pass pass:"Secret Passphrase" -e -base64
Entschlüsseln mit Kryptoes:
const decrypted = CryptoES.AES.decrypt(openSSLEncrypted, "Secret Passphrase");
Kryptos können von Codierungsformaten wie Base64, Latin1 oder Hex in WordArray -Objekte und Vica Versa konvertieren.
const words = CryptoES.enc.Base64.parse('SGVsbG8sIFdvcmxkIQ==');
const base64 = CryptoES.enc.Base64.stringify(words);
const words = CryptoES.enc.Base64url.parse('SGVsbG8sIFdvcmxkIQ==');
const base64url = CryptoES.enc.Base64.stringify(words);
const words = CryptoES.enc.Latin1.parse('Hello, World!');
const latin1 = CryptoES.enc.Latin1.stringify(words);
const words = CryptoES.enc.Hex.parse('48656c6c6f2c20576f726c6421');
const hex = CryptoES.enc.Hex.stringify(words);
const words = CryptoES.enc.Utf8.parse('?');
const utf8 = CryptoES.enc.Utf8.stringify(words);
const words = CryptoES.enc.Utf16.parse('Hello, World!');
const utf16 = CryptoES.enc.Utf16.stringify(words);
const words = CryptoES.enc.Utf16LE.parse('Hello, World!');
const utf16 = CryptoES.enc.Utf16LE.stringify(words);
WordArray -Schöpfer könnte einen ArrayBuffer oder Typedarray aufnehmen, damit Kryptoes -Algorismen für sie gelten können:
const words = CryptoES.lib.WordArray.create(new ArrayBuffer(8));
const rst = CryptoES.AES.encrypt(words, 'Secret Passphrase')
Hinweis : ArrayBuffer konnte nicht direkt an Algorismen übergeben, Sie sollten sie zuerst in WordArray ändern.
Auf diese Weise wären Verschlüsselungsdateien einfacher:
const fileInput = document.getElementById('fileInput');
const file = fileInput.files[0];
const reader = new FileReader();
reader.readAsArrayBuffer(file);
reader.onload = function () {
const arrayBuffer = reader.result;
const words = CryptoES.lib.WordArray.create(arrayBuffer);
const rst = CryptoES.AES.encrypt(words, 'Secret Passphrase')
...
};
Protokoll ändern
Refactoring Cryptojs im modernen ECMascript
