The Blowfish algorithm is a symmetric block cipher algorithm. The core of the algorithm is subkey generation, which extends the variable length key into a subkey array with a total length of 4168 Bytes. A large number of subkeys are used in the algorithm, and the subkeys are dependent on the user key. In the actual encryption/decryption process, the updated subkey array is used, and the subkeys are the P array and the S box. The Blowfish algorithm has a core encryption function: BF_En(). The input of this function is 64-bit plaintext information, which is output as 64-bit ciphertext information. Encrypting information with the Blowfish algorithm requires two processes: key preprocessing and information encryption. Similarly, decryption requires two processes, key preprocessing and information decryption.
The source key of the Blowfish algorithm - pbox and sbox is fixed, and we need to encrypt a message, we need to choose a key, use this key to transform pbox and sbox, get the key_pbox and key_sbox to use for the next information encryption. The same is true for decryption. Since Blowfish is a symmetric encryption algorithm, the decryption party generates the key_box and key_sbox required for decryption according to the key after obtaining the key. Encryption and decryption of the same information, the difference in the selected key will result in different ciphertext. Therefore, the key to the Blowfish algorithm is the choice of keys and privacy.
Because the Blowfish algorithm uses variable length keys, this brings great convenience to users and also has hidden dangers. Since the core of the algorithm encryption/decryption lies in the selection and secrecy of the key, in practice, some weak keys are often used to encrypt the information resources, resulting in a great security risk.
Blowfish.
Before the code, let's talk about the characteristics of the Blowfish encryption algorithm:
1. Symmetric encryption, that is, the encrypted key and the decrypted key are the same;
2. The result after each encryption is different (this is also a point that the old husband appreciates more);
3. Reversible, different from the abstract algorithm such as md5 introduced by the old man's previous article, he is reversible;
4. Fast, the process of encryption and decryption is basically composed of ADD and XOR instruction operations;
5. Free of charge, free for anyone to pay royalties;
6. BlowFish can only encrypt and decrypt 8 bytes of data at a time;
Next is the most important part, the implementation of the Blowfish encryption algorithm:
Package cn.bridgeli.encrypt;
Public enum BlowfishManager {
BRIDGELI_CN ("bridgeli_cn!@#$abc123_");
Private BlowfishManager(String secret) {
This.blowfish = new Blowfish(secret);
}
Private Blowfish blowfish;
Public Blowfish getBlowfish() {
Return blowfish;
}
/**
* Decrypt
* @param sCipherText
* @return
*/
Public String decryptString(String sCipherText){
Return this.getBlowfish().decryptString(sCipherText);
}
/**
* Encryption
* @param sPlainText
* @return
*/
Public String encryptString(String sPlainText){
Return this.getBlowfish().encryptString(sPlainText);
}
Public staTIc void main(String[] args) {
String encryptString = BlowfishManager.BRIDGELI_CN.encryptString(10 + "");
System.out.println(encryptString);
String decryptString = BlowfishManager.BRIDGELI_CN.decryptString(encryptString);
System.out.println(decryptString);
}
}
This is an external interface that is very simple to use and user friendly. Here is the specific implementation of the algorithm:
Package cn.bridgeli.encrypt;
Import java.security.MessageDigest;
Import java.uTIl.Random;
Import org.slf4j.Logger;
Import org.slf4j.LoggerFactory;
Public class Blowfish {
Private staTIc final Logger LOG = LoggerFactory.getLogger(Blowfish.class);
Private staTIc class BlowfishCBC extends BlowfishECB {
Public void setCBCIV(long lNewCBCIV) {
m_lCBCIV = lNewCBCIV;
}
Public void setCBCIV(byte newCBCIV[]) {
m_lCBCIV = Blowfish.byteArrayToLong(newCBCIV, 0);
}
@Override
Public void cleanUp() {
m_lCBCIV = 0L;
super.cleanUp();
}
Private long encryptBlockCBC(long lPlainblock) {
lPlainblock ^= m_lCBCIV;
lPlainblock = super.encryptBlock(lPlainblock);
Return m_lCBCIV = lPlainblock;
}
Private long decryptBlockCBC(long lCipherblock) {
Long lTemp = lCipherblock;
lCipherblock = super.decryptBlock(lCipherblock);
lCipherblock ^= m_lCBCIV;
m_lCBCIV = lTemp;
Return lCipherblock;
}
Public void encrypt(byte buffer[]) {
Int nLen = buffer.length;
For (int nI = 0; nI "nLen; nI += 8) {
Long lTemp = Blowfish.byteArrayToLong(buffer, nI);
lTemp = encryptBlockCBC(lTemp);
Blowfish.longToByteArray(lTemp, buffer, nI);
}
}
Public void decrypt(byte buffer[]) {
Int nLen = buffer.length;
For (int nI = 0; nI "nLen; nI += 8) {
Long lTemp = Blowfish.byteArrayToLong(buffer, nI);
lTemp = decryptBlockCBC(lTemp);
Blowfish.longToByteArray(lTemp, buffer, nI);
}
}
Long m_lCBCIV;
Public BlowfishCBC(byte bfkey[]) {
Super(bfkey);
setCBCIV(0L);
}
Public BlowfishCBC(byte bfkey[], long lInitCBCIV) {
Super(bfkey);
setCBCIV(lInitCBCIV);
}
Public BlowfishCBC(byte bfkey[], byte initCBCIV[]) {
Super(bfkey);
setCBCIV(initCBCIV);
}
}
Private static class BlowfishECB {
Public void cleanUp() {
For (int nI = 0; nI "18; nI++) {
M_pbox[nI] = 0;
}
For (int nI = 0; nI "256; nI++) {
M_sbox1[nI] = m_sbox2[nI] = m_sbox3[nI] = m_sbox4[nI] = 0;
}
}
Protected long encryptBlock(long lPlainBlock) {
Int nHi = Blowfish.longHi32(lPlainBlock);
Int nLo = Blowfish.longLo32(lPlainBlock);
Int sbox1[] = m_sbox1;
Int sbox2[] = m_sbox2;
Int sbox3[] = m_sbox3;
Int sbox4[] = m_sbox4;
Int pbox[] = m_pbox;
nHi ^= pbox[0];
nLo ^= (sbox1[nHi 》》 24] + sbox2[nHi 》》 16 & 0xff] ^ sbox3[nHi 》》 8 & 0xff])
+ sbox4[nHi & 0xff] ^ pbox[1];
nHi ^= (sbox1[nLo》》》 24] + sbox2[nLo》》 16 & 0xff] ^ sbox3[nLo》》 8 & 0xff])
+ sbox4[nLo & 0xff] ^ pbox[2];
nLo ^= (sbox1[nHi 》》 24] + sbox2[nHi 》》 16 & 0xff] ^ sbox3[nHi 》》 8 & 0xff])
+ sbox4[nHi & 0xff] ^ pbox[3];
nHi ^= (sbox1[nLo》》》 24] + sbox2[nLo》》 16 & 0xff] ^ sbox3[nLo》》 8 & 0xff])
+ sbox4[nLo & 0xff] ^ pbox[4];
nLo ^= (sbox1[nHi 》》 24] + sbox2[nHi 》》 16 & 0xff] ^ sbox3[nHi 》》 8 & 0xff])
+ sbox4[nHi & 0xff] ^ pbox[5];
nHi ^= (sbox1[nLo》》》 24] + sbox2[nLo》》 16 & 0xff] ^ sbox3[nLo》》 8 & 0xff])
+ sbox4[nLo & 0xff] ^ pbox[6];
nLo ^= (sbox1[nHi 》》 24] + sbox2[nHi 》》 16 & 0xff] ^ sbox3[nHi 》》 8 & 0xff])
+ sbox4[nHi & 0xff] ^ pbox[7];
nHi ^= (sbox1[nLo》》》 24] + sbox2[nLo》》 16 & 0xff] ^ sbox3[nLo》》 8 & 0xff])
+ sbox4[nLo & 0xff] ^ pbox[8];
nLo ^= (sbox1[nHi 》》 24] + sbox2[nHi 》》 16 & 0xff] ^ sbox3[nHi 》》 8 & 0xff])
+ sbox4[nHi & 0xff] ^ pbox[9];
nHi ^= (sbox1[nLo》》》 24] + sbox2[nLo》》 16 & 0xff] ^ sbox3[nLo》》 8 & 0xff])
+ sbox4[nLo & 0xff] ^ pbox[10];
nLo ^= (sbox1[nHi 》》 24] + sbox2[nHi 》》 16 & 0xff] ^ sbox3[nHi 》》 8 & 0xff])
+ sbox4[nHi & 0xff] ^ pbox[11];
nHi ^= (sbox1[nLo》》》 24] + sbox2[nLo》》 16 & 0xff] ^ sbox3[nLo》》 8 & 0xff])
+ sbox4[nLo & 0xff] ^ pbox[12];
nLo ^= (sbox1[nHi 》》 24] + sbox2[nHi 》》 16 & 0xff] ^ sbox3[nHi 》》 8 & 0xff])
+ sbox4[nHi & 0xff] ^ pbox[13];
nHi ^= (sbox1[nLo》》》 24] + sbox2[nLo》》 16 & 0xff] ^ sbox3[nLo》》 8 & 0xff])
+ sbox4[nLo & 0xff] ^ pbox[14];
nLo ^= (sbox1[nHi 》》 24] + sbox2[nHi 》》 16 & 0xff] ^ sbox3[nHi 》》 8 & 0xff])
+ sbox4[nHi & 0xff] ^ pbox[15];
nHi ^= (sbox1[nLo》》》 24] + sbox2[nLo》》 16 & 0xff] ^ sbox3[nLo》》 8 & 0xff])
+ sbox4[nLo & 0xff] ^ pbox[16];
Return Blowfish.makeLong(nHi, nLo ^ pbox[17]);
}
Protected long decryptBlock(long lCipherBlock) {
Int nHi = Blowfish.longHi32(lCipherBlock);
Int nLo = Blowfish.longLo32(lCipherBlock);
nHi ^= m_pbox[17];
nLo ^= (m_sbox1[nHi 》》 24] + m_sbox2[nHi 》》 16 & 0xff] ^ m_sbox3[nHi 》》 8 & 0xff])
+ m_sbox4[nHi & 0xff] ^ m_pbox[16];
nHi ^= (m_sbox1[nLo 》》 24] + m_sbox2[nLo 》》 16 & 0xff] ^ m_sbox3[nLo 》》 8 & 0xff])
+ m_sbox4[nLo & 0xff] ^ m_pbox[15];
nLo ^= (m_sbox1[nHi 》》 24] + m_sbox2[nHi 》》 16 & 0xff] ^ m_sbox3[nHi 》》 8 & 0xff])
+ m_sbox4[nHi & 0xff] ^ m_pbox[14];
nHi ^= (m_sbox1[nLo 》》 24] + m_sbox2[nLo 》》 16 & 0xff] ^ m_sbox3[nLo 》》 8 & 0xff])
+ m_sbox4[nLo & 0xff] ^ m_pbox[13];
nLo ^= (m_sbox1[nHi 》》 24] + m_sbox2[nHi 》》 16 & 0xff] ^ m_sbox3[nHi 》》 8 & 0xff])
+ m_sbox4[nHi & 0xff] ^ m_pbox[12];
nHi ^= (m_sbox1[nLo 》》 24] + m_sbox2[nLo 》》 16 & 0xff] ^ m_sbox3[nLo 》》 8 & 0xff])
+ m_sbox4[nLo & 0xff] ^ m_pbox[11];
nLo ^= (m_sbox1[nHi 》》 24] + m_sbox2[nHi 》》 16 & 0xff] ^ m_sbox3[nHi 》》 8 & 0xff])
+ m_sbox4[nHi & 0xff] ^ m_pbox[10];
nHi ^= (m_sbox1[nLo 》》 24] + m_sbox2[nLo 》》 16 & 0xff] ^ m_sbox3[nLo 》》 8 & 0xff])
+ m_sbox4[nLo & 0xff] ^ m_pbox[9];
nLo ^= (m_sbox1[nHi 》》 24] + m_sbox2[nHi 》》 16 & 0xff] ^ m_sbox3[nHi 》》 8 & 0xff])
+ m_sbox4[nHi & 0xff] ^ m_pbox[8];
nHi ^= (m_sbox1[nLo 》》 24] + m_sbox2[nLo 》》 16 & 0xff] ^ m_sbox3[nLo 》》 8 & 0xff])
+ m_sbox4[nLo & 0xff] ^ m_pbox[7];
nLo ^= (m_sbox1[nHi 》》 24] + m_sbox2[nHi 》》 16 & 0xff] ^ m_sbox3[nHi 》》 8 & 0xff])
+ m_sbox4[nHi & 0xff] ^ m_pbox[6];
nHi ^= (m_sbox1[nLo 》》 24] + m_sbox2[nLo 》》 16 & 0xff] ^ m_sbox3[nLo 》》 8 & 0xff])
+ m_sbox4[nLo & 0xff] ^ m_pbox[5];
nLo ^= (m_sbox1[nHi 》》 24] + m_sbox2[nHi 》》 16 & 0xff] ^ m_sbox3[nHi 》》 8 & 0xff])
+ m_sbox4[nHi & 0xff] ^ m_pbox[4];
nHi ^= (m_sbox1[nLo 》》 24] + m_sbox2[nLo 》》 16 & 0xff] ^ m_sbox3[nLo 》》 8 & 0xff])
+ m_sbox4[nLo & 0xff] ^ m_pbox[3];
nLo ^= (m_sbox1[nHi 》》 24] + m_sbox2[nHi 》》 16 & 0xff] ^ m_sbox3[nHi 》》 8 & 0xff])
+ m_sbox4[nHi & 0xff] ^ m_pbox[2];
nHi ^= (m_sbox1[nLo 》》 24] + m_sbox2[nLo 》》 16 & 0xff] ^ m_sbox3[nLo 》》 8 & 0xff])
+ m_sbox4[nLo & 0xff] ^ m_pbox[1];
Return Blowfish.makeLong(nHi, nLo ^ m_pbox[0]);
}
Int m_pbox[];
Int m_sbox1[];
Int m_sbox2[];
Int m_sbox3[];
Int m_sbox4[];
Static final int pbox_init[] = { 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x3707344, 0xa4093822,
0x299f31d0, 0x82efa98, 0xec4e6c89, 0x452821e6, 0x38d01377,
0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5,
0xb5470917, 0x9216d5d9, 0x8979fb1b };
Static final int sbox_init_1[] = { 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
0x24a19947, 0xb3916cf7, 0x801f2e2, 0x858efc16,
0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
0xd95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
0x23893e81, 0xd396acc5, 0xf6d6ff3, 0x83f44239,
0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
0x75372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x4c006ba,
0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, 0x250e2d,
0x2071b35e, 0x226800bb, 0x57b8e0af, 0x2464369b,
0xf009b91e, 0x5563911d, 0x59dfa6aa, 0x78c14389,
0xd95a537f, 0x207d5ba2, 0x2e5b9c5, 0x83260376,
0x6295cfa9, 0x11c81968, 0x4e734a41, 0xb3472dca,
0x7b14a94a, 0x1b510052, 0x9a532915, 0xd60f573f,
0xbc9bc6e4, 0x2b60a476, 0x81e67400, 0x8ba6fb5,
0x571be91f, 0xf296ec6b, 0x2a0dd915, 0xb6636521,
0xe7b9f9b6, 0xff34052e, 0xc5855664, 0x53b02d5d,
0xa99f8fa1, 0x8ba4799, 0x6e85076a };
Static final int sbox_init_2[] = { 0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x21ecc5e, 0x9686b3f,
0x3ebaefc9, 0x3c971814, 0x6b6a70a1, 0x687f3584,
0x52a0e286, 0xb79c5305, 0xaa500737, 0x3e07841c,
0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, 0xb03ada37,
0xf0500c0d, 0xf01c1f04, 0x200b3ff, 0xae0cf51a,
0x3cb574b2, 0x25837a58, 0xdc0921bd, 0xd19113f9,
0x7ca92ff6, 0x94324773, 0x22f54701, 0x3ae5e581,
0x37c2dadc, 0xc8b57634, 0x9af3dda7, 0xa9446146,
0xfd0030e, 0xecc8c73e, 0xa4751e41, 0xe238cd99,
0x3bea0e2f, 0x3280bba1, 0x183eb331, 0x4e548b38,
0x4f6db908, 0x6f420d03, 0xf60a04bf, 0x2cb81290,
0x24977c79, 0x5679b072, 0xbcaf89af, 0xde9a771f,
0xd9930810, 0xb38bae12, 0xdccf3f2e, 0x5512721f,
0x2e6b7124, 0x501adde6, 0x9f84cd87, 0x7a584718,
0x7408da17, 0xbc9f9abc, 0xe94b7d8c, 0xec7aec3a,
0xdb851dfa, 0x63094366, 0xc464c3d2, 0xef1c1847,
0x3215d908, 0xdd433b37, 0x24c2ba16, 0x12a14d43,
0x2a65c451, 0x50940002, 0x133ae4dd, 0x71dff89e,
0x10314e55, 0x81ac77d6, 0x5f11199b, 0x43556f1,
0xd7a3c76b, 0x3c11183b, 0x5924a509, 0xf28fe6ed,
0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, 0x86e34570,
0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, 0x771fe71c,
0x4e3d06fa, 0x2965dcb9, 0x99e71d0f, 0x803e89d6,
0x5266c825, 0x2e4cc978, 0x9c10b36a, 0xc6150eba,
0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, 0xf2f74ea7,
0x361d2b3d, 0x1939260f, 0x19c27960, 0x5223a708,
0xf71312b6, 0xebadfe6e, 0xeac31f66, 0xe3bc4595,
0xa67bc883, 0xb17f37d1, 0x18cff28, 0xc332ddef,
0xbe6c5aa5, 0x65582185, 0x68ab9802, 0xeecea50f,
0xdb2f953b, 0x2aef7dad, 0x5b6e2f84, 0x1521b628,
0x29076170, 0xecdd4775, 0x619f1510, 0x13cca830,
0xeb61bd96, 0x334fe1e, 0xaa0363cf, 0xb5735c90,
0x4c70a239, 0xd59e9e0b, 0xcbaade14, 0xeecc86bc,
0x60622ca7, 0x9cab5cab, 0xb2f3846e, 0x648b1eaf,
0x19bdf0ca, 0xa02369b9, 0x655abb50, 0x40685a32,
0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7, 0x9b540b19,
0x875fa099, 0x95f7997e, 0x623d7da8, 0xf837889a,
0x97e32d77, 0x11ed935f, 0x16681281, 0xe358829,
0xc7e61fd6, 0x96dedfa1, 0x7858ba99, 0x57f584a5,
0x1b227263, 0x9b83c3ff, 0x1ac24696, 0xcdb30aeb,
0x532e3054, 0x8fd948e4, 0x6dbc3128, 0x58ebf2ef,
0x34c6ffea, 0xfe28ed61, 0xee7c3c73, 0x5d4a14d9,
0xe864b7e3, 0x42105d14, 0x203e13e0, 0x45eee2b6,
0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0, 0xc742f442,
0xef6abbb5, 0x654f3b1d, 0x41cd2105, 0xd81e799e,
0x86854dc7, 0xe44b476a, 0x3d816250, 0xcf62a1f2,
0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, 0x7f1524c3,
0x69cb7492, 0x47848a0b, 0x5692b285, 0x95bbf00,
0xad19489d, 0x1462b174, 0x23820e00, 0x58428d2a,
0xc55f5ea, 0x1dadf43e, 0x233f7061, 0x3372f092,
0x8d937e41, 0xd65fecf1, 0x6c223bdb, 0x7cde3759,
0xcbee7460, 0x4085f2a7, 0xce77326e, 0xa6078084,
0x19f8509e, 0xe8efd855, 0x61d99735, 0xa969a7aa,
0xc50c06c2, 0x5a04abfc, 0x800bcadc, 0x9e447a2e,
0xc3453484, 0xfdd56705, 0xe1e9ec9, 0xdb73dbd3,
0x105588cd, 0x675fda79, 0xe3674340, 0xc5c43465,
0x713e38d8, 0x3d28f89e, 0xf16dff20, 0x153e21e7,
0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7 };
Static final int sbox_init_3[] = { 0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
0xbfbc09ec, 0x3bd9785, 0x7fac6dd0, 0x31cb8504,
0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
0x28507825, 0x530429f4, 0xa2c86da, 0xe9b66dfb,
0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
0xfdf8e802, 0x4272f70, 0x80bb155c, 0x5282ce3, 0x95c11548,
0xe4c66d22, 0x48c1133f, 0xc70f86dc, 0x7f9c9ee,
0x41041f0f, 0x404779a4, 0x5d886e17, 0x325f51eb,
0xd59bc0d1, 0xf2bcc18f, 0x41113564, 0x257b7834,
0x602a9c60, 0xdff8e8a3, 0x1f636c1b, 0xe12b4c2, 0x2e1329e,
0xaf664fd1, 0xcad18115, 0x6b2395e0, 0x333e92e1,
0x3b240b62, 0xeebeb922, 0x85b2a20e, 0xe6ba0d99,
0xde720c8c, 0x2da2f728, 0xd0127845, 0x95b794fd,
0x647d0862, 0xe7ccf5f0, 0x5449a36f, 0x877d48fa,
0xc39dfd27, 0xf33e8d1e, 0xa476341, 0x992eff74,
0x3a6f6eab, 0xf4f8fd37, 0xa812dc60, 0xa1ebddf8,
0x991be14c, 0xdb6e6b0d, 0xc67b5510, 0x6d672c37,
0x2765d43b, 0xdcd0e804, 0xf1290dc7, 0xcc00ffa3,
0xb5390f92, 0x690fed0b, 0x667b9ffb, 0xcedb7d9c,
0xa091cf0b, 0xd9155ea3, 0xbb132f88, 0x515bad24,
0x7b9479bf, 0x763bd6eb, 0x37392eb3, 0xcc115979,
0x8026e297, 0xf42e312d, 0x6842ada7, 0xc66a2b3b,
0x12754ccc, 0x782ef11c, 0x6a124237, 0xb79251e7,
0x6a1bbe6, 0x4bfb6350, 0x1a6b1018, 0x11caedfa,
0x3d25bdd8, 0xe2e1c3c9, 0x44421659, 0xa121386,
0xd90cec6e, 0xd5abea2a, 0x64af674e, 0xda86a85f,
0xbebfe988, 0x64e4c3fe, 0x9dbc8057, 0xf0f7c086,
0x60787bf8, 0x6003604d, 0xd1fd8346, 0xf6381fb0,
0x7745ae04, 0xd736fccc, 0x83426b33, 0xf01eab71,
0xb0804187, 0x3c005e5f, 0x77a057be, 0xbde8ae24,
0x55464299, 0xbf582e61, 0x4e58f48f, 0xf2ddfda2,
0xf474ef38, 0x8789bdc2, 0x5366f9c3, 0xc8b38e74,
0xb475f255, 0x46fcd9b9, 0x7aeb2661, 0x8b1ddf84,
0x846a0e79, 0x915f95e2, 0x466e598e, 0x20b45770,
0x8cd55591, 0xc902de4c, 0xb90bace1, 0xbb8205d0,
0x11a86248, 0x7574a99e, 0xb77f19b6, 0xe0a9dc09,
0x662d09a1, 0xc4324633, 0xe85a1f02, 0x9f0be8c,
0x4a99a025, 0x1d6efe10, 0x1ab93d1d, 0xba5a4df,
0xa186f20f, 0x2868f169, 0xdcb7da83, 0x573906fe,
0xa1e2ce9b, 0x4fcd7f52, 0x50115e01, 0xa70683fa,
0xa002b5c4, 0xde6d027, 0x9af88c27, 0x773f8641,
0xc3604c06, 0x61a806b5, 0xf0177a28, 0xc0f586e0, 0x6058aa,
0x30dc7d62, 0x11e69ed7, 0x2338ea63, 0x53c2dd94,
0xc2c21634, 0xbbcbee56, 0x90bcb6de, 0xebfc7da1,
0xce591d76, 0x6f05e409, 0x4b7c0188, 0x39720a3d,
0x7c927c24, 0x86e3725f, 0x724d9db9, 0x1ac15bb4,
0xd39eb8fc, 0xed545578, 0x8fca5b5, 0xd83d7cd3,
0x4dad0fc4, 0x1e50ef5e, 0xb161e6f8, 0xa28514d9,
0x6c51133c, 0x6fd5c7e7, 0x56e14ec4, 0x362abfce,
0xddc6c837, 0xd79a3234, 0x92638212, 0x670efa8e,
0x406000e0 };
Static final int sbox_init_4[] = { 0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x22b8b51,
0x96d5ac3a, 0x17da67d, 0xd1cf3ed6, 0x7c7d2d28,
0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
0x15056dd4, 0x88f46dba, 0x3a16125, 0x564f0bd, 0xc3eb9e15,
0x3c9057a2, 0x97271aec, 0xa93a072a, 0x1b3f6d9b,
0x1e6321f5, 0xf59c66fb, 0x26dcf319, 0x7533d928,
0xb155fdf5, 0x3563482, 0x8aba3cbb, 0x28517711,
0xc20ad9f8, 0xabcc5167, 0xccad925f, 0x4de81751,
0x3830dc8e, 0x379d5862, 0x9320f991, 0xea7a90c2,
0xfb3e7bce, 0x5121ce64, 0x774fbe32, 0xa8b6e37e,
0xc3293d46, 0x48de5369, 0x6413e680, 0xa2ae0810,
0xdd6db224, 0x69852dfd, 0x9072166, 0xb39a460a,
0x6445c0dd, 0x586cdecf, 0x1c20c8ae, 0x5bbef7dd,
0x1b588d40, 0xccd2017f, 0x6bb4e3bb, 0xdda26a7e,
0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, 0x72eacea8,
0xfa6484bb, 0x8d6612ae, 0xbf3c6f47, 0xd29be463,
0x542f5d9e, 0xaec2771b, 0xf64e6370, 0x740e0d8d,
0xe75b1357, 0xf8721671, 0xaf537d5d, 0x4040cb08,
0x4eb4e2cc, 0x34d2466a, 0x115af84, 0xe1b00428,
0x95983a1d, 0x6b89fb4, 0xce6ea048, 0x6f3f3b82,
0x3520ab82, 0x11a1d4b, 0x277227f8, 0x611560b1,
0xe7933fdc, 0xbb3a792b, 0x344525bd, 0xa08839e1,
0x51ce794b, 0x2f32c9b7, 0xa01fbac9, 0xe01cc87e,
0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, 0x1a908749,
0xd44fbd9a, 0xd0dadecb, 0xd50ada38, 0x339c32a,
0xc6913667, 0x8df9317c, 0xe0b12b4f, 0xf79e59b7,
0x43f5bb3a, 0xf2d519ff, 0x27d9459c, 0xbf97222c,
0x15e6fc2a, 0xf91fc71, 0x9b941525, 0xfae59361,
0xceb69ceb, 0xc2a86459, 0x12baa8d1, 0xb6c1075e,
0xe3056a0c, 0x10d25065, 0xcb03a442, 0xe0ec6e0e,
0x1698db3b, 0x4c98a0be, 0x3278e964, 0x9f1f9532,
0xe0d392df, 0xd3a0342b, 0x8971f21e, 0x1b0a7441,
0x4ba3348c, 0xc5be7120, 0xc37632d8, 0xdf359f8d,
0x9b992f2e, 0xe60b6f47, 0xfe3f11d, 0xe54cda54,
0x1edad891, 0xce6279cf, 0xcd3e7e6f, 0x1618b166,
0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, 0xf523f357,
0xa6327623, 0x93a83531, 0x56cccd02, 0xacf08162,
0x5a75ebb5, 0x6e163697, 0x88d273cc, 0xde966292,
0x81b949d0, 0x4c50901b, 0x71c65614, 0xe6c6c7bd,
0x327a140a, 0x45e1d006, 0xc3f27b9a, 0xc9aa53fd,
0x62a80f00, 0xbb25bfe2, 0x35bdd2f6, 0x71126905,
0xb2040222, 0xb6cbcf7c, 0xcd769c2b, 0x53113ec0,
0x1640e3d3, 0x38abbd60, 0x2547adf0, 0xba38209c,
0xf746ce76, 0x77afa1c5, 0x20756060, 0x85cbfe4e,
0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, 0x1948c25c,
0x2fb8a8c, 0x1c36ae4, 0xd6ebe1f9, 0x90d4f869, 0xa65cdea0,
0x3f09252d, 0xc208e69f, 0xb74e6132, 0xce77e25b,
0x578fdfe3, 0x3ac372e6 };
Public BlowfishECB(byte bfkey[]) {
M_pbox = new int[18];
For (int nI = 0; nI "18; nI++) {
M_pbox[nI] = pbox_init[nI];
}
M_sbox1 = new int[256];
M_sbox2 = new int[256];
M_sbox3 = new int[256];
M_sbox4 = new int[256];
For (int nI = 0; nI "256; nI++) {
M_sbox1[nI] = sbox_init_1[nI];
M_sbox2[nI] = sbox_init_2[nI];
M_sbox3[nI] = sbox_init_3[nI];
M_sbox4[nI] = sbox_init_4[nI];
}
Int nLen = bfkey.length;
If (nLen == 0) {
Return;
}
Int nKeyPos = 0;
Int nBuild = 0;
For (int nI = 0; nI "18; nI++) {
For (int nJ = 0; nJ "4; nJ++) {
nBuild = nBuild "8 | bfkey[nKeyPos] & 0xff;
If (++nKeyPos == nLen) {
nKeyPos = 0;
}
}
M_pbox[nI] ^= nBuild;
}
Long lZero = 0L;
For (int nI = 0; nI "18; nI += 2) {
lZero = encryptBlock(lZero);
M_pbox[nI] = (int) (lZero 》》 32);
M_pbox[nI + 1] = (int) (lZero & 0xffffffffL);
}
For (int nI = 0; nI "256; nI += 2) {
lZero = encryptBlock(lZero);
M_sbox1[nI] = (int) (lZero 》》 32);
M_sbox1[nI + 1] = (int) (lZero & 0xffffffffL);
}
For (int nI = 0; nI "256; nI += 2) {
lZero = encryptBlock(lZero);
M_sbox2[nI] = (int) (lZero 》》 32);
M_sbox2[nI + 1] = (int) (lZero & 0xffffffffL);
}
For (int nI = 0; nI "256; nI += 2) {
lZero = encryptBlock(lZero);
M_sbox3[nI] = (int) (lZero 》》 32);
M_sbox3[nI + 1] = (int) (lZero & 0xffffffffL);
}
For (int nI = 0; nI "256; nI += 2) {
lZero = encryptBlock(lZero);
M_sbox4[nI] = (int) (lZero 》》 32);
M_sbox4[nI + 1] = (int) (lZero & 0xffffffffL);
}
}
}
Public Blowfish(String password) {
MessageDigest digest = null;
Try {
Digest = MessageDigest.getInstance("SHA1");
Digest.update(password.getBytes());
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
M_bfish = new BlowfishCBC(digest.digest(), 0L);
Digest.reset();
}
Public String encryptString(String sPlainText) {
Long lCBCIV;
Synchronized (m_rndGen) {
lCBCIV = m_rndGen.nextLong();
}
Return encStr(sPlainText, lCBCIV);
}
Private String encStr(String sPlainText, long lNewCBCIV) {
Int nStrLen = sPlainText.length();
Byte buf[] = new byte[(nStrLen 《1 & -8) + 8];
Int nPos = 0;
For (int nI = 0; nI "nStrLen; nI++) {
Char cActChar = sPlainText.charAt(nI);
Buf[nPos++] = (byte) (cActChar 》 8 & 0xff);
Buf[nPos++] = (byte) (cActChar & 0xff);
}
Byte bPadVal = (byte) (buf.length - (nStrLen "1));
While (nPos " buf.length ) {
Buf[nPos++] = bPadVal;
}
m_bfish.setCBCIV(lNewCBCIV);
M_bfish.encrypt(buf);
Byte newCBCIV[] = new byte[8];
longToByteArray(lNewCBCIV, newCBCIV, 0);
Return bytesToBinHex(newCBCIV, 0, 8) + bytesToBinHex(buf, 0, buf.length);
}
Public String decryptString(String sCipherText) {
Int nLen = sCipherText.length() 》》 1 & -8;
If (nLen " 8) {
Return null;
}
Byte cbciv[] = new byte[8];
Int nNumOfBytes = binHexToBytes(sCipherText, cbciv, 0, 0, 8);
If (nNumOfBytes " 8) {
Return null;
}
m_bfish.setCBCIV(cbciv);
If ((nLen -= 8) == 0) {
Return "";
}
Byte buf[] = new byte[nLen];
nNumOfBytes = binHexToBytes(sCipherText, buf, 16, 0, nLen);
If (nNumOfBytes nLen) {
Return null;
}
M_bfish.decrypt(buf);
Int nPadByte = buf[buf.length - 1] & 0xff;
If (nPadByte 》 8 || nPadByte < 0) {
nPadByte = 0;
}
nNumOfBytes -= nPadByte;
If (nNumOfBytes "0") {
Return "";
} else {
Return byteArrayToUNCString(buf, 0, nNumOfBytes);
}
}
Public void destroy() {
m_bfish.cleanUp();
}
Private static long byteArrayToLong(byte buffer[], int nStartIndex) {
Return (long) buffer[nStartIndex] "56 | (buffer[nStartIndex + 1] & 255L) "48
| (buffer[nStartIndex + 2] & 255L) "40
| (buffer[nStartIndex + 3] & 255L) "32
| (buffer[nStartIndex + 4] & 255L) "24
| (buffer[nStartIndex + 5] & 255L) "16
| (buffer[nStartIndex + 6] & 255L) "8 | buffer[nStartIndex + 7]
& 255L;
}
Private static void longToByteArray(long lValue, byte buffer[], int nStartIndex) {
Buffer[nStartIndex] = (byte) (int) (lValue 》》 56);
Buffer[nStartIndex + 1] = (byte) (int) (lValue "》 48 & 255L);
Buffer[nStartIndex + 2] = (byte) (int) (lValue 》》 40 & 255L);
Buffer[nStartIndex + 3] = (byte) (int) (lValue 》》 32 & 255L);
Buffer[nStartIndex + 4] = (byte) (int) (lValue 》》 24 & 255L);
Buffer[nStartIndex + 5] = (byte) (int) (lValue "" 16 & 255L);
Buffer[nStartIndex + 6] = (byte) (int) (lValue 》》 8 & 255L);
Buffer[nStartIndex + 7] = (byte) (int) lValue;
}
Private static long makeLong(int nLo, int nHi) {
Return (long) nHi "32 | nLo & 0xffffffffL;
}
Private static int longLo32(long lVal) {
Return (int) lVal;
}
Private static int longHi32(long lVal) {
Return (int) (lVal 》》 32);
}
Private static String bytesToBinHex(byte data[], int nStartPos, int nNumOfBytes) {
StringBuffer sbuf = new StringBuffer();
sbuf.setLength(nNumOfBytes "1";
Int nPos = 0;
For (int nI = 0; nI "nNumOfBytes; nI++) {
sbuf.setCharAt(nPos++, HEXTAB[data[nI + nStartPos]》 4 & 0xf]);
sbuf.setCharAt(nPos++, HEXTAB[data[nI + nStartPos] & 0xf]);
}
Return sbuf.toString();
}
Private static int binHexToBytes(String sBinHex, byte data[], int nSrcPos, int nDstPos,
Int nNumOfBytes) {
Int nStrLen = sBinHex.length();
Int nAvailBytes = nStrLen - nSrcPos 》 1 1;
If (nAvailBytes " nNumOfBytes) {
nNumOfBytes = nAvailBytes;
}
int nOutputCapacity = data.length - nDstPos;
if （nNumOfBytes 》 nOutputCapacity） {
nNumOfBytes = nOutputCapacity;
}
int nResult = 0;
for （int nI = 0; nI 《 nNumOfBytes; nI++） {
byte bActByte = 0;
boolean blConvertOK = true;
for （int nJ = 0; nJ 《 2; nJ++） {
bActByte 《《= 4;
char cActChar = sBinHex.charAt（nSrcPos++）;
if （cActChar 》= 'a' && cActChar 《= 'f'） {
bActByte |= （byte） （cActChar - 97） + 10;
continue;
}
if （cActChar 》= '0' && cActChar 《= '9'） {
bActByte |= （byte） （cActChar - 48）;
} else {
blConvertOK = false;
}
}
if （blConvertOK） {
dataï¼»nDstPos++ï¼½ = bActByte;
nResult++;
}
}
return nResult;
}
private static String byteArrayToUNCString（byte data［］， int nStartPos， int nNumOfBytes） {
nNumOfBytes &= -2;
int nAvailCapacity = data.length - nStartPos;
if （nAvailCapacity 《 nNumOfBytes） {
nNumOfBytes = nAvailCapacity;
}
StringBuffer sbuf = new StringBuffer（）;
sbuf.setLength（nNumOfBytes 》》 1）;
int nSBufPos = 0;
for （; nNumOfBytes 》 0; nNumOfBytes -= 2） {
sbuf.setCharAt（nSBufPos++， （char） （data［nStartPos］ 《《 8 | data［nStartPos + 1］ & 0xff））;
nStartPos += 2;
}
return sbuf.toString（）;
}
private BlowfishCBC m_bfish;
private static Random m_rndGen = new Random（）;
static final char HEXTAB［］ = { '0'， '1'， '2'， '3'， '4'， '5'， '6'， '7'， '8'， '9'， 'a'， 'b'， 'c'， 'd'， 'e'， 'f' };
}
Product Description
SPD Surge Protective Device,Lightning Surge Protector
Surge Protection Device (SPD)
It is a device used to limiting instant surge voltage and discharge surge current, it at least including a non-linear component.
Surge protective Device Model Selection
With the impact of international information flow, the rapid development of microelectronic science and technology, communication, computer and automatic control technology, make the building start to go for high quality, high functional area, formed a new building style-intelligent building. As inside the intelligent building there are lot of information system, <<Building lightning protection design norm>> GB50057-94(2002 vision)(hereafter brief as <<lightning protection norm>>) put forward the relative requirement to install the surge protective device, to ensure the information system safely and stable running.
SPD essentially is a equipotential connection material, its model selection is according to the different lightning protection area, different lightning electromagnetic pulse critical and different equipotential connection position, decide which kind of SPD used in the area, to achieve the equipotential connection with the common earth electrode. Our statement will based on SPD's maximum discharge current Imax, continuous operating voltage Uc, protection voltage Up, alarm mode etc.
As per << Lightning Protection Norm>> item 6.4.4 stipulation "SPD must can withstand the expected lightning current flow and should confirm to the additional two requirements: the maximum clamp voltage during surge across, capable to extinguish the power frequency follow-on current after lightning current across." That is the value of SPD's max. clamp voltage add its induction voltage of two ends should be same with the system's basic insulation level and the equipment allowed max. surge voltage.
SPD for Power Supply System Series Selection Guide
The installation of SPD at each lightning protection zone, according to the standard of low voltage electrical appearance, make classification of electrical equipment in accordance with the over voltage category, its insulation withstand impulse voltage level can determine the selection of SPD. According to the standard of low voltage electrical appearance, make classification of electrical equipment in accordance with the over voltage category as signal level, loading level, distribution and control level, power supply level. Its insulation withstand impulse voltage level are:1500V,2500V,4000V,6000V. As per to the protected equipment installation position different and the different lightning current of different lightning protection zone, to determine the installation position of SPD for power supply and the break-over capacity.
The installation distance between each level SPD should not more than 10m, the distance between SPD and protected equipment should as short as possible, not more than 10m. If due to limitation of installation position, can't guarantee the installation distance, then need to install decoupling component between each level SPD, make the after class SPD can be protected by the prior class SPD. In the low voltage power supply system, connecting an inductor can achieve the decoupling purpose.
SPD for power supply system specification selection principle
Max. continuous operating voltage: bigger than protected equipment, the system's max. continuous operating voltage.
TT System: Uc≥1.55Uo (Uo is low voltage system to null line voltage)
TN System: Uc≥1.15Uo
IT System: Uc≥1.15Uo(Uo is low voltage system to line voltage)
Voltage Protection Level: less than the insulation withstand impulse voltage of protected equipment
Rated discharge current: determined as per to the lightning situation of the position installed and lightning protection zone.
SP1 Series
Normal Working Conditions
-Altitude not exceed 2000m
-Ambient air temperature:
Normal range: -5ºC~+40ºC
Extend range: -40ºC~+80ºC
-Relative Humidity: 30% - 90% under indoor temperature condition
- At the place without obviously shaking and shock vibration
- Non-explosion danger medium, non-corrosion gas and dust ( including conductive dust)
Classification
-As per Nominal Discharge Current:
5,10,20,30,40,60KA(8/20µs)
- As per Maximum continuous operating voltage:
275V,320V,385V,420V,440V,460V
- As per to poles
1P,1P+N,2P,3P,3P+N,4P
- As per auxiliary functions:
a. With remote signal output ( remote alarm function)
b. Without remote signal output
Selection Principle
- The continuous applied voltage on the two terminals of SPD should not more than the maximum continuous operating voltage Uc value;
- The voltage protection level Up of SPD should less than the maximum impulse withstand voltage of the protected equipment;
- As per to the different earthing system and protection mode to select the specification accordingly;
Product Features
1, built-in over-current overheating, temperature control circuit technology.
2, the module design, easy installation, online replacement.
3, low leakage current, fast response time, low residual voltage.
4, alarm indication device, green (normal) v red (fault).
| Model/Technical Parameters | WR-B60 | WR-B80 | WR-B100 | WR-B120 | WR-B150 |
| Rated Operating Voltage Un (V ~) | 220V 380V | 220V 380V | 220V 380V | 220V 380V | 220V 380V |
| Maximum Continuous Operating Voltage Uc (V ~) kV | 385V 420V | 385V 420V | 385V 420V | 385V 420V | 385V 420V |
| Voltage Protection Level Up (V ~) kV | ≤1.8≤2.2 | ≤2.4≤2.5 | ≤2.5≤3.2 | ≤3.4≤3.7 | ≤4.0≤4.5 |
|
Maximum Discharge Current Imax(8/μ20μs)kA |
60 | 80 | 100 | 120 | 150 |
|
Nominal Discharge Current In(8/μ20μs)kA |
30 | 40 | 60 | 80 | 100 |
| Response Time | <25 | <100 | |||
| L/N(mm²)The Cross Section Of L/N Line | 16,25 | 16,25 | 16,25 | 16,25 | 25,35 |
| PE (mm²)The Cross Section Of PE Line | 16,25 | 25,35 | 25,35 | 25,35 | 35 |
| Fuse or Switch (A) | 63A | 63A | 63A,100A | 63A,100A | 63A,125A |
| The Line Section of Communication and Alarm (mm²) | ≥ 1.5 | ||||
|
Operating Environment-C |
(-40ºC~-+85ºC) | ||||
| Relative humidity 25 ºC | ≤95% | ||||
| installation | Standard Rail35mm | ||||
| Material of Outer Covering | Fiber Glass Reinforced Plastic | ||||
Surge Protector SPD,Surge Protection Device SPD,SPD
Wenzhou Korlen Electric Appliances Co., Ltd. , https://www.zjmannualmotorstarter.com