/* KeyLoader.java nov 2000 * * Erwan Lemonnier & Eric Nordenstam * * IO interface to read/write clear and encrypted data * to and from files. ************************************************************/ import java.math.BigInteger; import java.io.*; /** * DataLoader is an IO interface used by RSA to read * and write clear and encrypted data. Its default is * that it is not bufferised, thus each call to a read * method results in a disk access. As well for writes. *
* It was necessary to define a format for blocks of * data. In this implementation, clear data is read by * blocks of at most 126 bytes, and inserted in a 128 bytes * large integer whose first byte is the length of the block * of clear data read. This integer is then encrypted using rsa, * and can be written to and read from a file. When decrypted * and written as clear data to a file, only the number of bytes * specified in the first bytes is indeed written to the file. *
* @author E.Lemonnier & E.Nordenstam */ public class DataLoader { private static FileInputStream in; private static FileOutputStream out; //size of key in bits private static int SIZE_KEY = RSA.SIZE_KEY; //size of clear data block, in bytes private static int SIZE_CLEAR_BLOCK = (2*SIZE_KEY-16)/8; //size of crypted data block, in bytes private static int SIZE_CRYPTED_BLOCK = (2*SIZE_KEY)/8; /** * Create a DataLoader defined by an file from which to read * and a file in which to write. *
* @param filein a file from which to read. * @param fileout a file in which to write. */ public DataLoader(String filein, String fileout) throws Exception { in = new FileInputStream(filein); out = new FileOutputStream(fileout); } /** * Close the streams manipulated by a DataLoader. */ public void close() { try { in.close(); out.flush(); out.close(); } catch(Exception e) {} } /** * Read a block of data from a clear file. *
* @return the block of data as a big integer of 1024 bits. */ public BigInteger readClearBlock() throws IOException { //one more byte to store the number of read bytes byte[] b = new byte[SIZE_CLEAR_BLOCK+1]; int l = in.read(b, 1, SIZE_CLEAR_BLOCK); if (l == -1) throw new IOException(); //set the most significant byte to the number of bytes read b[0] = (byte)l; return new BigInteger(b); } /** * Read a block of encrypted data from an encrypted file. *
* @return the block of data as a big integer of 1024 bits. */ public BigInteger readEncryptedBlock() throws IOException { byte[] b = new byte[SIZE_CRYPTED_BLOCK]; if (in.read(b) == -1) throw new IOException(); return new BigInteger(b); } /** * Write a block of clear data to a file. *
* @param b clear data encapsulated in a 128 bytes integer. */ public void writeClearBlock(BigInteger b) throws IOException { byte[] bytes = b.toByteArray(); out.write(bytes, 1, (int)bytes[0]); } /** * Write a block of encrypted data to a file. *
* @param a 1024 bits integer representing encrypted data.
*/
public void writeEncryptedBlock(BigInteger b) throws IOException {
byte[] bytes = b.toByteArray();
out.write(bytes);
if (bytes.length