Scrypt演算法簡介
Scrypt是記憶體依賴型的POW演算法，萊特幣采用此演算法，第一個使用Scrypt演算法的數字貨幣是Tenebrix，而后該演算法被萊特幣使用，萊特幣創始人在萊特幣創世帖中介紹了萊特幣采用的共識機制，挖礦演算法，發行總量，挖礦難度等相關重要資訊，李啟威說明了萊特幣所使用的挖礦演算法為數字貨幣Tenebrix所使用的Scrypt演算法，是一種符合PoW共識機制的演算法，Scrypt演算法程序中也需要計算哈希值，但是，Scrypt計算程序中需要使用較多的記憶體資源，
其它使用Scrypt演算法的數字貨幣還有數碼幣（DigitalCoin）、狗狗幣（DogeCoin）、幸運幣（LuckyCoin）、世界幣（WorldCoin）等，
Scrypt的誕生
由于位元幣將hash演算法作為pow作業量證明的重要手段，后續的各種采用pow的數字貨幣也延續了這個設計，以SHA256、MD5（MD5后來被證明不具備強碰撞性數字貨幣一般不用）為代表演算法在設計之初屬于演算法都是算力敏感型，意味著計算資源是瓶頸，主頻越高的 CPU 進行 Hash 的速度也越快，這個設計直接導致后來的礦機出現，采用ASIC芯片的礦機更是將這種運算能力成倍提升，更多礦場的出現使得當時的位元幣面臨算力中心化的威脅（關于礦場這個爭論現在依舊）
為了限制計算能力的依賴，人們開始尋求新的演算法，我們說過現代計算機是“存盤轉發結構”，既然要限制轉發CPU的能力，目光自然投向存盤依賴，也就是記憶體依賴，萊特幣率先使用記憶體依賴型的scrypt演算法作為pow核心，因此奠定了第一山寨幣的地位，
scrpyt演算法是由著名的FreeBSD黑客 Colin Percival為他的備份服務 Tarsnap開發的，當初的設計是為了降低CPU負荷，盡量少的依賴cpu計算，利用CPU閑置時間進行計算，因此scrypt不僅計算所需時間長，而且占用的記憶體也多，使得并行計算多個摘要例外困難，因此利用rainbow table進行暴力攻擊更加困難，scrypt沒有在生產環境中大規模應用，并且缺乏仔細的審察和廣泛的函式庫支持，所以scrpyt一直沒有推廣開，但是由于其記憶體依賴的設計特別符合當時對抗專業礦機的設計，成為數字貨幣演算法發展的一個主要應用方向，
后來有人在SCRYPT的基礎上稍作修改形成Scrypt –N演算法，改進思路都一樣，都是追求更大的記憶體消耗和計算時間，以有效阻止ASIC專用礦機，
Scrypt演算法來源
scrypt是由著名的FreeBSD黑客 Colin Percival為他的備份服務 Tarsnap開發的，剛開始只是用于防止網路攻擊用的，但是后來逐漸延用到虛擬貨幣的技術上，
Scrypt演算法有哪些好處？
scrypt加密演算法不僅計算所需時間長，而且占用的記憶體也多，使得并行計算多個摘要例外困難，因此利用rainbow table進行暴力攻擊更加困難，scrypt沒有在生產環境中大規模應用，并且缺乏仔細的審察和廣泛的函式庫支持，但是，scrypt在演算法層面只要沒有破綻，它的安全性應該高于PBKDF2和bcrypt，并且以特幣將scrypt演算法用于挖礦演算法中，將scrypt演算法的優勢充分發揮出來，
在經歷了位元幣風波之后，投資者對于虛擬貨幣的安全是越來越重視，而以特幣現在采用的scrypt加密演算法卻剛好滿足了交易者的需求，不僅實作了交易安全保護，而且實作了匿名交易，能夠最大程度上保護交易者的隱私，
以特幣的scrypt加密演算法使得以特幣的交易自主性、獨立性增強，能夠不受任何政府和組織的控制，進一步的維護了以特幣的交易安全，
而以特幣的這一優點也是位元幣所不具備的，當中國宣布位元幣退出中國市場的交易時，位元幣意味著失去了百分之六十的市場，位元幣的這一失足也給虛擬貨幣的發展潑了一盆冷水，但是以特幣對于scrypt演算法的運用卻完全消除了這一弊端，scrept演算法為虛擬貨幣的發展注入了新活力，也為以特幣的進一步發展打下了良好的基礎，
Scrpyt后續影響
雖然后來誕生的FPGA礦機可以有效運行scrpyt演算法進行大規模挖礦，（FPGA和ASIC類似，FGPA板每塊有高達24.8GB/s或以上的記憶體帶寬，屬于專用可編程芯片，其實顯卡挖礦也是利用了顯卡GPU計算能力和記憶體帶寬能力），但是scrpyt演算法的使用開啟了人們對于hash計算去中心化安全的探索，
后來誕生過串行演算法，并行演算法等等，其中X11就是使用了11種加密演算法（BLAKE, BMW, GROESTL, JH, KECCAK, SKEIN, LUFFA, CUBEHASH, SHAVITE, SIMD, ECHO）
不要被這些演算法嚇到，其實就是對一段資料進行了11次不同演算法的運算，通過運算復雜度增強安全性和加大計算資源消耗，一方面更安全，另一方面抵抗專業硬體編程礦機，后來認為這種串行方式一個演算法被攻破實際上會導致整個體系安全性受到攻擊，又發展出并行演算法，
所謂并行就是將資料進行分塊，比如切分成11份，每一份使用不同演算法計算，再拼接不同的結算結果而已，
由于pow演算法依賴計算資源，不論是CPU或者是記憶體依賴，到后期總會有更專門的硬體出現，這是計算機體系結構決定的，后期誕生的幣種或相關專案將目光投向pos證明機制，不再依賴算力，這也是發展的必然結果，雖然目前pos機制還在發展中，但是未來這是抵御中心化算力更好的方式，
scrpyt的價值在于提醒了人們對于算力中心化的認識，促進了區塊鏈系統向更好的方向發展，我認為這是一個里程碑式的演算法，估計該演算法的發明人也沒有想到scrpyt在區塊鏈世界是那么的重要，
使用POM
<dependency>
<groupId>com.lambdaworks</groupId>
<artifactId>scrypt</artifactId>
<version>1.4.0</version>
</dependency>
Java實作：
import com.lambdaworks.jni.*;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.security.GeneralSecurityException;
import static java.lang.Integer.MAX_VALUE;
import static java.lang.System.arraycopy;
public class SCrypt {
private static final boolean native_library_loaded;
static {
LibraryLoader loader = LibraryLoaders.loader();
native_library_loaded = loader.load("scrypt", true);
}
/**
* @param passwd Password.
* @param salt Salt.
* @param N CPU cost parameter.
* @param r Memory cost parameter.
* @param p Parallelization parameter.
* @param dkLen Intended length of the derived key.
*
/
public static byte[] scrypt(byte[] passwd, byte[] salt, int N, int r, int p, int dkLen) throws GeneralSecurityException {
return native_library_loaded ? scryptN(passwd, salt, N, r, p, dkLen) : scryptJ(passwd, salt, N, r, p, dkLen);
}
/**
* Native C implementation of the <a href="http://www.tarsnap.com/scrypt/scrypt.pdf"/>scrypt KDF</a> using
* the code from <a href="http://www.tarsnap.com/scrypt.html">http://www.tarsnap.com/scrypt.html<a>.
*
* @param passwd Password.
* @param salt Salt.
* @param N CPU cost parameter.
* @param r Memory cost parameter.
* @param p Parallelization parameter.
* @param dkLen Intended length of the derived key.
*
* @return The derived key.
*/
public static native byte[] scryptN(byte[] passwd, byte[] salt, int N, int r, int p, int dkLen);
/**
* Pure Java implementation of the <a href="http://www.tarsnap.com/scrypt/scrypt.pdf"/>scrypt KDF</a>.
*
* @param passwd Password.
* @param salt Salt.
* @param N CPU cost parameter.
* @param r Memory cost parameter.
* @param p Parallelization parameter.
* @param dkLen Intended length of the derived key.
*
* @return The derived key.
*
* @throws GeneralSecurityException when HMAC_SHA256 is not available.
*/
public static byte[] scryptJ(byte[] passwd, byte[] salt, int N, int r, int p, int dkLen) throws GeneralSecurityException {
if (N < 2 || (N & (N - 1)) != 0) throw new IllegalArgumentException("N must be a power of 2 greater than 1");
if (N > MAX_VALUE / 128 / r) throw new IllegalArgumentException("Parameter N is too large");
if (r > MAX_VALUE / 128 / p) throw new IllegalArgumentException("Parameter r is too large");
Mac mac = Mac.getInstance("HmacSHA256");
mac.init(new SecretKeySpec(passwd, "HmacSHA256"));
byte[] DK = new byte[dkLen];
byte[] B = new byte[128 * r * p];
byte[] XY = new byte[256 * r];
byte[] V = new byte[128 * r * N];
int i;
PBKDF.pbkdf2(mac, salt, 1, B, p * 128 * r);
for (i = 0; i < p; i++) {
smix(B, i * 128 * r, r, N, V, XY);
}
PBKDF.pbkdf2(mac, B, 1, DK, dkLen);
return DK;
}
public static void smix(byte[] B, int Bi, int r, int N, byte[] V, byte[] XY) {
int Xi = 0;
int Yi = 128 * r;
int i;
arraycopy(B, Bi, XY, Xi, 128 * r);
for (i = 0; i < N; i++) {
arraycopy(XY, Xi, V, i * (128 * r), 128 * r);
blockmix_salsa8(XY, Xi, Yi, r);
}
for (i = 0; i < N; i++) {
int j = integerify(XY, Xi, r) & (N - 1);
blockxor(V, j * (128 * r), XY, Xi, 128 * r);
blockmix_salsa8(XY, Xi, Yi, r);
}
arraycopy(XY, Xi, B, Bi, 128 * r);
}
public static void blockmix_salsa8(byte[] BY, int Bi, int Yi, int r) {
byte[] X = new byte[64];
int i;
arraycopy(BY, Bi + (2 * r - 1) * 64, X, 0, 64);
for (i = 0; i < 2 * r; i++) {
blockxor(BY, i * 64, X, 0, 64);
salsa20_8(X);
arraycopy(X, 0, BY, Yi + (i * 64), 64);
}
for (i = 0; i < r; i++) {
arraycopy(BY, Yi + (i * 2) * 64, BY, Bi + (i * 64), 64);
}
for (i = 0; i < r; i++) {
arraycopy(BY, Yi + (i * 2 + 1) * 64, BY, Bi + (i + r) * 64, 64);
}
}
public static int R(int a, int b) {
return (a << b) | (a >>> (32 - b));
}
public static void salsa20_8(byte[] B) {
int[] B32 = new int[16];
int[] x = new int[16];
int i;
for (i = 0; i < 16; i++) {
B32[i] = (B[i * 4 + 0] & 0xff) << 0;
B32[i] |= (B[i * 4 + 1] & 0xff) << 8;
B32[i] |= (B[i * 4 + 2] & 0xff) << 16;
B32[i] |= (B[i * 4 + 3] & 0xff) << 24;
}
arraycopy(B32, 0, x, 0, 16);
for (i = 8; i > 0; i -= 2) {
x[ 4] ^= R(x[ 0]+x[12], 7); x[ 8] ^= R(x[ 4]+x[ 0], 9);
x[12] ^= R(x[ 8]+x[ 4],13); x[ 0] ^= R(x[12]+x[ 8],18);
x[ 9] ^= R(x[ 5]+x[ 1], 7); x[13] ^= R(x[ 9]+x[ 5], 9);
x[ 1] ^= R(x[13]+x[ 9],13); x[ 5] ^= R(x[ 1]+x[13],18);
x[14] ^= R(x[10]+x[ 6], 7); x[ 2] ^= R(x[14]+x[10], 9);
x[ 6] ^= R(x[ 2]+x[14],13); x[10] ^= R(x[ 6]+x[ 2],18);
x[ 3] ^= R(x[15]+x[11], 7); x[ 7] ^= R(x[ 3]+x[15], 9);
x[11] ^= R(x[ 7]+x[ 3],13); x[15] ^= R(x[11]+x[ 7],18);
x[ 1] ^= R(x[ 0]+x[ 3], 7); x[ 2] ^= R(x[ 1]+x[ 0], 9);
x[ 3] ^= R(x[ 2]+x[ 1],13); x[ 0] ^= R(x[ 3]+x[ 2],18);
x[ 6] ^= R(x[ 5]+x[ 4], 7); x[ 7] ^= R(x[ 6]+x[ 5], 9);
x[ 4] ^= R(x[ 7]+x[ 6],13); x[ 5] ^= R(x[ 4]+x[ 7],18);
x[11] ^= R(x[10]+x[ 9], 7); x[ 8] ^= R(x[11]+x[10], 9);
x[ 9] ^= R(x[ 8]+x[11],13); x[10] ^= R(x[ 9]+x[ 8],18);
x[12] ^= R(x[15]+x[14], 7); x[13] ^= R(x[12]+x[15], 9);
x[14] ^= R(x[13]+x[12],13); x[15] ^= R(x[14]+x[13],18);
}
for (i = 0; i < 16; ++i) B32[i] = x[i] + B32[i];
for (i = 0; i < 16; i++) {
B[i * 4 + 0] = (byte) (B32[i] >> 0 & 0xff);
B[i * 4 + 1] = (byte) (B32[i] >> 8 & 0xff);
B[i * 4 + 2] = (byte) (B32[i] >> 16 & 0xff);
B[i * 4 + 3] = (byte) (B32[i] >> 24 & 0xff);
}
}
public static void blockxor(byte[] S, int Si, byte[] D, int Di, int len) {
for (int i = 0; i < len; i++) {
D[Di + i] ^= S[Si + i];
}
}
public static int integerify(byte[] B, int Bi, int r) {
int n;
Bi += (2 * r - 1) * 64;
n = (B[Bi + 0] & 0xff) << 0;
n |= (B[Bi + 1] & 0xff) << 8;
n |= (B[Bi + 2] & 0xff) << 16;
n |= (B[Bi + 3] & 0xff) << 24;
return n;
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/qukuanlian/277732.html
標籤：區塊鏈