/** * Do the appropriate processing for CFB mode encryption. * * @param in the array containing the data to be encrypted. * @param inOff offset into the in array the data starts at. * @param out the array the encrypted data will be copied into. * @param outOff the offset into the out array the output will start at. * @exception DataLengthException if there isn't enough data in in, or * space in out. * @exception IllegalStateException if the cipher isn't initialised. * @return the number of bytes processed and produced. */ public int encryptBlock( byte[] inBytes, int inOff, byte[] outBytes, int outOff) //throws DataLengthException, StateException { if ((inOff + blockSize) > inBytes.Length) { throw new DataLengthException("input buffer too short"); } if ((outOff + blockSize) > outBytes.Length) { throw new DataLengthException("output buffer too short"); } cipher.processBlock(cfbV, 0, cfbOutV, 0); // // XOR the cfbV with the plaintext producing the cipher text // for (int i = 0; i < blockSize; i++) { outBytes[outOff + i] = (byte)(cfbOutV[i] ^ inBytes[inOff + i]); } // // change over the input block. // Array.Copy(cfbV, blockSize, cfbV, 0, cfbV.Length - blockSize); Array.Copy(outBytes, outOff, cfbV, cfbV.Length - blockSize, blockSize); return(blockSize); }
/** * Do the appropriate chaining step for CBC mode encryption. * * @param in the array containing the data to be encrypted. * @param inOff offset into the in array the data starts at. * @param out the array the encrypted data will be copied into. * @param outOff the offset into the out array the output will start at. * @exception DataLengthException if there isn't enough data in in, or * space in out. * @exception IllegalStateException if the cipher isn't initialised. * @return the number of bytes processed and produced. */ private int encryptBlock( byte[] inBytes, int inOff, byte[] outBytes, int outOff) //throws DataLengthException, IllegalStateException { if ((inOff + blockSize) > inBytes.Length) { throw new DataLengthException("input buffer too short"); } /* * XOR the cbcV and the input, * then encrypt the cbcV */ for (int i = 0; i < blockSize; i++) { cbcV[i] ^= inBytes[inOff + i]; } int length = cipher.processBlock(cbcV, 0, outBytes, outOff); /* * copy ciphertext to cbcV */ Array.Copy(outBytes, outOff, cbcV, 0, cbcV.Length); return(length); }
/** * encrypt/decrypt a single byte returning the result. * * @param in the byte to be processed. * @return the result of processing the input byte. */ public byte returnByte( byte inByte) { oneByte[0] = inByte; cipher.processBlock(oneByte, 0, oneByte, 0); return(oneByte[0]); }
public void update( byte inByte) { int resultLen = 0; if (bufOff == buf.Length) { resultLen = cipher.processBlock(buf, 0, mac, 0); bufOff = 0; } buf[bufOff++] = inByte; }
public byte[] wrap( byte[] inBytes, int inOff, int inLen) { if (!forWrapping) { throw new Exception("not set for wrapping"); } int n = inLen / 8; if ((n * 8) != inLen) { throw new DataLengthException("wrap data must be a multiple of 8 bytes"); } byte[] block = new byte[inLen + iv.Length]; byte[] buf = new byte[8 + iv.Length]; Array.Copy(iv, 0, block, 0, iv.Length); Array.Copy(inBytes, 0, block, iv.Length, inLen); engine.init(true, param); for (int j = 0; j != 6; j++) { for (int i = 1; i <= n; i++) { Array.Copy(block, 0, buf, 0, iv.Length); Array.Copy(block, 8 * i, buf, iv.Length, 8); engine.processBlock(buf, 0, buf, 0); int t = n * j + i; for (int k = 1; t != 0; k++) { byte v = (byte)t; buf[iv.Length - k] ^= v; t = (int)((uint)t >> 8); } Array.Copy(buf, 0, block, 0, 8); Array.Copy(buf, 8, block, 8 * i, 8); } } return(block); }
/** * process a single byte, producing an output block if neccessary. * * @param in the input byte. * @param out the space for any output that might be produced. * @param outOff the offset from which the output will be copied. * @return the number of output bytes copied to out. * @exception DataLengthException if there isn't enough space in out. * @exception IllegalStateException if the cipher isn't initialised. */ public virtual int processByte( byte inByte, byte[] outBytes, int outOff) //throws DataLengthException, IllegalStateException { int resultLen = 0; buf[bufOff++] = inByte; if (bufOff == buf.Length) { resultLen = cipher.processBlock(buf, 0, outBytes, outOff); bufOff = 0; } return(resultLen); }
public int processBlock(byte[] inBytes, int inOff, byte[] outBytes, int outOff) //throws DataLengthException, IllegalStateException { cipher.processBlock(counter, 0, counterOut, 0); // // XOR the counterOut with the plaintext producing the cipher text // for (int i = 0; i < counterOut.Length; i++) { outBytes[outOff + i] = (byte)(counterOut[i] ^ inBytes[inOff + i]); } BigInteger bi = new BigInteger(counter); bi.add(ONE); counter = bi.toByteArray(); return(counter.Length); }