[JavaScript知识库]柜子端的交互与实现

2021SC@SDUSC

柜子加密算法

选择AES对柜子进行加密，有明文P、密钥K、AES加密函数、密文C、AES解密函数、对称加密算法、非对称加密算法等。AES为分组密码，分组密码也就是把明文分成一组一组的，每组长度相等，每次加密一组数据，直到加密完整个明文。在AES标准规范中，分组长度只能是128位，也就是说，每个分组为16个字节（每个字节8位）。密钥的长度可以使用128位、192位或256位。密钥的长度不同，推荐加密轮数也不同。

在项目中用到了AES对柜子端进行加密。

import { getAction } from '@/api/manage'
import { ENCRYPTED_STRING } from "@/store/mutation-types"
import Vue from 'vue'

/**
 * 获取加密字符串，并对结果进行缓存
 */
export function getEncryptedString() {
  return getAction("/sys/getEncryptedString",{}).then((res)=>{
    let encryptedString = {};
    encryptedString.key = res.result.key;
    encryptedString.iv = res.result.iv;
    Vue.ls.set(ENCRYPTED_STRING, encryptedString, 7 * 24 * 60 * 60 * 1000);
    return encryptedString;
  });
}

/**
 * AES加密 ：字符串 key iv  返回base64
 */
export function encryption(word, keyStr, ivStr) {

  let key = CryptoJS.enc.Utf8.parse(keyStr)
  let iv = CryptoJS.enc.Utf8.parse(ivStr)

  let srcs = CryptoJS.enc.Utf8.parse(word);
  var encrypted = CryptoJS.AES.encrypt(srcs, key, {
    iv: iv,
    mode: CryptoJS.mode.CBC,
    padding: CryptoJS.pad.ZeroPadding
  });
  // console.log("-=-=-=-", encrypted.ciphertext)
  return CryptoJS.enc.Base64.stringify(encrypted.ciphertext);

}


var CryptoJS = CryptoJS || (function (Math, undefined) {
  /*
	     * Local polyfil of Object.create
	     */
  var create = Object.create || (function () {
    function F() {};

    return function (obj) {
      var subtype;

      F.prototype = obj;

      subtype = new F();

      F.prototype = null;

      return subtype;
    };
  }())

  /**
   * CryptoJS namespace.
   */
  var C = {};

  /**
   * Library namespace.
   */
  var C_lib = C.lib = {};

  /**
   * Base object for prototypal inheritance.
   */
  var Base = C_lib.Base = (function () {


    return {
     
      extend: function (overrides) {
        // Spawn
        var subtype = create(this);

        // Augment
        if (overrides) {
          subtype.mixIn(overrides);
        }

        // Create default initializer
        if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
          subtype.init = function () {
            subtype.$super.init.apply(this, arguments);
          };
        }

        // Initializer's prototype is the subtype object
        subtype.init.prototype = subtype;

        // Reference supertype
        subtype.$super = this;

        return subtype;
      },

     
      create: function () {
        var instance = this.extend();
        instance.init.apply(instance, arguments);

        return instance;
      },

    
      init: function () {
      },

      
      mixIn: function (properties) {
        for (var propertyName in properties) {
          if (properties.hasOwnProperty(propertyName)) {
            this[propertyName] = properties[propertyName];
          }
        }

        // IE won't copy toString using the loop above
        if (properties.hasOwnProperty('toString')) {
          this.toString = properties.toString;
        }
      },

     
      clone: function () {
        return this.init.prototype.extend(this);
      }
    };
  }());

  
  var WordArray = C_lib.WordArray = Base.extend({
    
    init: function (words, sigBytes) {
      words = this.words = words || [];

      if (sigBytes != undefined) {
        this.sigBytes = sigBytes;
      } else {
        this.sigBytes = words.length * 4;
      }
    },

    
    toString: function (encoder) {
      return (encoder || Hex).stringify(this);
    },

   
    concat: function (wordArray) {
      // Shortcuts
      var thisWords = this.words;
      var thatWords = wordArray.words;
      var thisSigBytes = this.sigBytes;
      var thatSigBytes = wordArray.sigBytes;

      // Clamp excess bits
      this.clamp();

      // Concat
      if (thisSigBytes % 4) {
        // Copy one byte at a time
        for (var i = 0; i < thatSigBytes; i++) {
          var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
          thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
        }
      } else {
        // Copy one word at a time
        for (var i = 0; i < thatSigBytes; i += 4) {
          thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
        }
      }
      this.sigBytes += thatSigBytes;

      // Chainable
      return this;
    },

    clamp: function () {
      // Shortcuts
      var words = this.words;
      var sigBytes = this.sigBytes;

      // Clamp
      words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
      words.length = Math.ceil(sigBytes / 4);
    },

    
    clone: function () {
      var clone = Base.clone.call(this);
      clone.words = this.words.slice(0);

      return clone;
    },

    random: function (nBytes) {
      var words = [];

      var r = (function (m_w) {
        var m_w = m_w;
        var m_z = 0x3ade68b1;
        var mask = 0xffffffff;

        return function () {
          m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;
          m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;
          var result = ((m_z << 0x10) + m_w) & mask;
          result /= 0x100000000;
          result += 0.5;
          return result * (Math.random() > .5 ? 1 : -1);
        }
      });

      for (var i = 0, rcache; i < nBytes; i += 4) {
        var _r = r((rcache || Math.random()) * 0x100000000);

        rcache = _r() * 0x3ade67b7;
        words.push((_r() * 0x100000000) | 0);
      }

      return new WordArray.init(words, nBytes);
    }
  });

 
  var C_enc = C.enc = {};


  var Hex = C_enc.Hex = {
    
    stringify: function (wordArray) {
      // Shortcuts
      var words = wordArray.words;
      var sigBytes = wordArray.sigBytes;

      // Convert
      var hexChars = [];
      for (var i = 0; i < sigBytes; i++) {
        var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
        hexChars.push((bite >>> 4).toString(16));
        hexChars.push((bite & 0x0f).toString(16));
      }

      return hexChars.join('');
    },

   
    parse: function (hexStr) {
      // Shortcut
      var hexStrLength = hexStr.length;

      // Convert
      var words = [];
      for (var i = 0; i < hexStrLength; i += 2) {
        words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
      }

      return new WordArray.init(words, hexStrLength / 2);
    }
  };

 
  var Latin1 = C_enc.Latin1 = {
    
    stringify: function (wordArray) {
      // Shortcuts
      var words = wordArray.words;
      var sigBytes = wordArray.sigBytes;

      // Convert
      var latin1Chars = [];
      for (var i = 0; i < sigBytes; i++) {
        var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
        latin1Chars.push(String.fromCharCode(bite));
      }

      return latin1Chars.join('');
    },

    
    parse: function (latin1Str) {
      // Shortcut
      var latin1StrLength = latin1Str.length;

      // Convert
      var words = [];
      for (var i = 0; i < latin1StrLength; i++) {
        words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
      }

      return new WordArray.init(words, latin1StrLength);
    }
  };

  
  var Utf8 = C_enc.Utf8 = {
   
    stringify: function (wordArray) {
      try {
        return decodeURIComponent(escape(Latin1.stringify(wordArray)));
      } catch (e) {
        throw new Error('Malformed UTF-8 data');
      }
    },

    parse: function (utf8Str) {
      return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
    }
  };

 
  var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
 
    reset: function () {
      // Initial values
      this._data = new WordArray.init();
      this._nDataBytes = 0;
    },

    _append: function (data) {
      // Convert string to WordArray, else assume WordArray already
      if (typeof data == 'string') {
        data = Utf8.parse(data);
      }

      // Append
      this._data.concat(data);
      this._nDataBytes += data.sigBytes;
    },

 
    _process: function (doFlush) {
      // Shortcuts
      var data = this._data;
      var dataWords = data.words;
      var dataSigBytes = data.sigBytes;
      var blockSize = this.blockSize;
      var blockSizeBytes = blockSize * 4;

      // Count blocks ready
      var nBlocksReady = dataSigBytes / blockSizeBytes;
      if (doFlush) {
        // Round up to include partial blocks
        nBlocksReady = Math.ceil(nBlocksReady);
      } else {
        // Round down to include only full blocks,
        // less the number of blocks that must remain in the buffer
        nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
      }

      // Count words ready
      var nWordsReady = nBlocksReady * blockSize;

      // Count bytes ready
      var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);

      // Process blocks
      if (nWordsReady) {
        for (var offset = 0; offset < nWordsReady; offset += blockSize) {
          // Perform concrete-algorithm logic
          this._doProcessBlock(dataWords, offset);
        }

        // Remove processed words
        var processedWords = dataWords.splice(0, nWordsReady);
        data.sigBytes -= nBytesReady;
      }

      // Return processed words
      return new WordArray.init(processedWords, nBytesReady);
    },

    clone: function () {
      var clone = Base.clone.call(this);
      clone._data = this._data.clone();

      return clone;
    },

    _minBufferSize: 0
  });

  var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
   
    cfg: Base.extend(),

    init: function (cfg) {
      // Apply config defaults
      this.cfg = this.cfg.extend(cfg);

      // Set initial values
      this.reset();
    },

2.存放物品时的顺序

首先顺序存放，然后如果有已经存放了的位置则向后延迟

@Override 
public Long getNextCupboardIndex() 
{ 
List<FileDocument> fileDocumentList = fileService.listFileByAbout(FileType.PDF); 
Map<Long, Integer> map = new HashMap<>();
for(FileDocument fileDocument : fileDocumentList) 
{ 
Long storageId = fileDocument.getStorageId(); 
if(map.containsKey(storageId)) 
{ 
int size = map.get(storageId); 
map.put(storageId, size + 1); 
}else { map.put(storageId, 1); 
}
}
long minStorageId = 0L; 
int minValue = 10000000; 
for(long i = 0; i < 8; i++) 
{ if(!map.containsKey(i)) 
{ minStorageId = i; break; 
}if(map.get(i) < minValue) 
{ minStorageId = i; 
minValue = map.get(i);
 } 
}return minStorageId; 
}

3.开柜码的生成

@Override 
public String openBoard(Long userId, Integer op, String fileId) { 
FileDocument fileDocument = fileService.getFileById(fileId); 
if(fileDocument == null) 
{ 
throw new CustomException("未找到文件"); 
}
Affair affair = affairService.getAffair(userId, fileDocument.getAboutId()); if(!affair.getState().equals(AffairType.STATE_END)) 
{ 
throw new CustomException("affair is not finish"); }
if(!fileDocument.getAbout().equals(FileType.PDF)) 
{ throw new CustomException("文件不支持"); 
}if(!fileService.isAuth(userId, fileId)) 
{ 
throw new CustomException("该用户无该文件权限或者查看权限出错"); 
}Date now = DateUtils.addMinutes(new Date(), 3);
String storageId = fileDocument.getStorageId().toString(); String msg = op.toString() + "-" + storageId + "-" + fileDocument.getId() + "-" + now.getTime(); 
log.info(msg); String encoded = null; 
try 
{encoded = AESUtils.encrypt(msg); 
}catch (Exception e) 
{ throw new CustomException("encrypt is wrong"); 
}return encoded;
}