Recall, if you do the Modes.java assignment, you are creating various
static methods that act on StringBuffers.  Let me explain how everything
is supposed to plug in.

Suppose that you have created an RSA Kernel that:
1) Doesn't try to pad
2) Assumes that BOTH plain and cipher text are given as hexadecimal ascii,
with no whitespace -and now blocksizes are TWICE as big!!!

NOTE: (2) is a new assumption, but it makes life a little easier.

------------DISCUSSION OF HOW TO ACHIEVE CONDITION (2)---------
Requirement (2) is not hard to achieve.  Suppose you had code in a file
called
			RSAnoPads.java
which didn't try to pad and converted ASCII to BigInteger upon encryption
(as I suggested).

----SUB-DISCUSSION:  WHAT ORIGINAL RSA DID----
Recall that when the ASCII blocks are converted into
BigIntegers the following procedure is used on each block.  Suppose a
block of size 64 looked like:

c1, c2, c3, .... , c64

where c1 is the first char, c2 is the second char, etc.

What happens next is that we convert the unicode char's into bytes
(this is done using the getBytes() method of the String class.  So now we
have bytes:

b1, b2, b3, .... , b64

or as an array:

b[0], b[1], ... , b[63]

This is almost good enough to plug into BigInteger.  But we want to make
sure we have a non-negative integer that is smaller than the number N =
product of two primes.  Assumming that N has exactly 8*64 significant bits

(guys:  when picking your primes, MAKE SURE THIS HAPPENS IN YOUR RSA
CODE!!!  If you pick two random 8*32 bit primes, than you have better than
35% chance that their product will have exactly 8*64 significant bits, so
you don't have to search too long to get N = p1 * p2 of the required
length)

... back to the discussion...

assuming that N has exactly 8*64 significant bits, and since we want to
make sure the block is represented as a number in the range [0,N-1] the
easiest way to insure this is to set the most significant bit of b1 to 0
with the code
   b[0] &= (byte)127
with is the bitwize "and" of b[0] with the byte 01111111

Now what happened what that you feed the bytes into the BigInteger
constructor, which automatically glues the bytes together into a very long
integer.
--------------BACK TO DISCUSSING CONDITION (2):

BUT:  BigInteger, also has a constructor that takes hexadecimal strings.
Thus, upon encryption, we would have a bunch of hexadecimal digits that
looked like:

h1, h2, h3, .... , h128   (remember, blockas are TWICE as big)

Again, just-in-case, you should make sure the most significant digit
creates a number with less bits than N = p1*p2.  If h1 is in the range
[0,7] you're fine.  But if h1 is in the range [8,15], we have a problem,
and should reset with a command such as:
   h1 -= 8
to retain all the other bits (you can't do this exactly since
we're dealing with a part of a StringBuffer but you get the idea...) Now
if the text was actually originally 7-bit ASCII, all this discussion about
h-=8 (and also b[0] &= (byte)127) are moot and the code would work just as
well.  But just in case........include the code.

THE POINT????????
1) You should convert bytes to hex in an UNSIGNED fashion.  The easiest
way to do this is to cheat and use the code in BigInteger.  So a
conversion of a single block would look like:

String bytes2hex(String bstr, int blockSize){
   byte[] b = bstr.getBytes();
   b[0] &= (byte)127;
   String h = (new BigInteger(b)).toString(16); //base-26

   //finally, create and return correct size blocks
   if( h.length() <= blockSize){
      int zeroslength = blockSize - h.length();
      String leadingZeros = "";
      for(int i=0; i<zeroslength; i++) leadingZeros += '0';
      return leadingZeros+h;
   }

   //if the rest of your code is right should have already returned h
   //but just in case.... (for correct behavior in other code and
   //compilation)
   return h.substring(0,blockSize);
}

NOTE:  CONVERTING A WHOLE BUNCH OF BLOCKS IS A LITTLE MORE COMPLICATED
AND YOUR CONVERSION METHODS SHOULD HANDLE ALL THE BLOCKS AT ONCE.

2) You convert BigIntegers to hex by simplifying the above (you just don't
need the section that converts the String into a byte[] array.

3) Converting hex into BigIntegers is the easiest:  if h is the hex string
you just call
   new BigInteger(h,16)

4) Converting BigIntegers back into bytes (to get the ASCII) is also easy.
If  M is your BigInteger, you just call
   String str = new String(M.toByteArray());


WHOOO--- so now we know how to convert between all of the following
formats:

	o ASCII
	o BigInteger
	o Hex-ASCII

I recommend putting all these conversion methods in your Modes.java code.

So to satisfy condistion (2), supposing you had a class

RSAnoPads.java

that takes ASCII and encrypts to space separated BigInteger blocks

Now you want to create:

RSAnoPadsHex.java

that takes hex to hex without spaces.  Assuming all the real encryption
work of RSAnoPads.java is happening in encrypt() and encryptOn() just
wraps encrypt(),  your code could look like the following:

package webcrypt.crypto;
private class RSAnoPadsHex extends RSAnoPads{
   getBlockSize(){ return super.getBlockSize() * 2; }

   public StringBuffer encrypt(StringBuffer plainhex, Key k){
       StringBuffer plain = Modes.hex2ASCII(plainhex,getBlockSize());
       StringBuffer cipher = super.encrypt(plain,k);
       return Modes.BigIntegers2hex(cipher,getBlockSize());
   }

...decrypt() will be similar, but you have to reverse the conversion...
}

FINALLY!!!!!!
So how do we create RSACBC???

We want RSACBC to encrypt ASCII to hex blocks so we do as follows:

package webcrypt.crypto;
public RSACBC extends RSAnoPadsHex{
   public StringBuffer encrypt(StringBuffer plain, Key k){
       StringBuffer plainhex = Modes.ASCII2hex(plainhex,getBlockSize()/2);
       return Modes.CBCdo(plainhex,super,k,getBlockSize());
   }

...decrypt() will be similar, but reversed...
}

So we're only left with one question:  how about the CBC code?

package webcrypt.crypto;
public class Modes{
   ... other modes before...

   public static StringBuffer
     CBCdo(StringBuffer plainhex, Kernel ker, Key k, int blockSize){
      ...break the plain-text assumed to be HEX into blocks size blockSize
      ...pad the last block using Modes.pad()
      StringBuffer C = blocks[0]; //C0 in yesterday's notation
      StringBuffer cipherhex = new StringBuffer(C.toString());
      for(int i=1; i<blocks.length; i++){
         C = ker.encrypt(XOR(C,blocks[i]),k); //implement XOR elsewhere
         cipherhex.append(C);
      }
      return cipherhex;
   }

   ... other variants and modes after...
}

Hope that helps more than confuses.

-Zeph