public void Xor(BLOCK8BYTE a, BLOCK8BYTE b) { // Set byte to A ^ B for (int offset = 0; offset < BYTE_LENGTH; offset++) { _data[offset] = Convert.ToByte(a._data[offset] ^ b._data[offset]); } }
public void ShiftLeftWrapped(BLOCK8BYTE s, int bitShift) { // this shift is only applied to the first 32 bits, and parity bit is ignored // Declaration of local variables int byteOffset; bool bit; // Copy byte and shift regardless for (byteOffset = 0; byteOffset < 4; byteOffset++) { _data[byteOffset] = Convert.ToByte((s._data[byteOffset] << bitShift) & 0xFF); } // if shifting by 1... if (bitShift == 1) { // repair bits on right of BYTE for (byteOffset = 0; byteOffset < 3; byteOffset++) { // get repairing bit offsets bit = s.GetBit(byteOffset + 1, 7); this.SetBit(byteOffset, 1, bit); } // wrap around the final bit this.SetBit(3, 1, s.GetBit(0, 7)); } else if (bitShift == 2) { // repair bits on right of BYTE for (byteOffset = 0; byteOffset < 3; byteOffset++) { // get repairing bit offsets bit = s.GetBit(byteOffset + 1, 7); this.SetBit(byteOffset, 2, bit); bit = s.GetBit(byteOffset + 1, 6); this.SetBit(byteOffset, 1, bit); } // wrap around the final bit this.SetBit(3, 2, s.GetBit(0, 7)); this.SetBit(3, 1, s.GetBit(0, 6)); } else { Debug.Assert(false); } }
public void ShiftLeftWrapped(BLOCK8BYTE s, int bitShift) { // this shift is only applied to the first 32 bits, and parity bit is ignored // Declaration of local variables int byteOffset; bool bit; // Copy byte and shift regardless for (byteOffset = 0; byteOffset < 4; byteOffset++) _data[byteOffset] = Convert.ToByte((s._data[byteOffset] << bitShift) & 0xFF); // if shifting by 1... if (bitShift == 1) { // repair bits on right of BYTE for (byteOffset = 0; byteOffset < 3; byteOffset++) { // get repairing bit offsets bit = s.GetBit(byteOffset + 1, 7); this.SetBit(byteOffset, 1, bit); } // wrap around the final bit this.SetBit(3, 1, s.GetBit(0, 7)); } else if (bitShift == 2) { // repair bits on right of BYTE for (byteOffset = 0; byteOffset < 3; byteOffset++) { // get repairing bit offsets bit = s.GetBit(byteOffset + 1, 7); this.SetBit(byteOffset, 2, bit); bit = s.GetBit(byteOffset + 1, 6); this.SetBit(byteOffset, 1, bit); } // wrap around the final bit this.SetBit(3, 2, s.GetBit(0, 7)); this.SetBit(3, 1, s.GetBit(0, 6)); } else Debug.Assert(false); }
protected KeySet ExpandKey(byte[] key, int offset) { // // Expand an 8 byte DES key into a set of permuted keys // // Declare return variable KeySet ftmp = new KeySet(); // Declaration of local variables int arrayOffset, permOffset, byteOffset, bitOffset; bool bBit; // Put key into an 8-bit block BLOCK8BYTE k = new BLOCK8BYTE(); k.Set(key, offset); // Permutate Kp with PC1 BLOCK8BYTE kp = new BLOCK8BYTE(); for (arrayOffset = 0; arrayOffset < DESTables.PC1.Length; arrayOffset++) { // Get permute offset permOffset = DESTables.PC1[arrayOffset]; permOffset--; // Get and set bit kp.SetBit( BitAddressToByteOffset(arrayOffset, 7), BitAddressToBitOffset(arrayOffset, 7), k.GetBit( BitAddressToByteOffset(permOffset, 8), BitAddressToBitOffset(permOffset, 8) ) ); } // Create 17 blocks of C and D from Kp BLOCK8BYTE[] kpCn = new BLOCK8BYTE[17]; BLOCK8BYTE[] kpDn = new BLOCK8BYTE[17]; for (arrayOffset = 0; arrayOffset < 17; arrayOffset++) { kpCn[arrayOffset] = new BLOCK8BYTE(); kpDn[arrayOffset] = new BLOCK8BYTE(); } for (arrayOffset = 0; arrayOffset < 32; arrayOffset++) { // Set bit in KpCn byteOffset = BitAddressToByteOffset(arrayOffset, 8); bitOffset = BitAddressToBitOffset(arrayOffset, 8); bBit = kp.GetBit(byteOffset, bitOffset); kpCn[0].SetBit(byteOffset, bitOffset, bBit); // Set bit in KpDn bBit = kp.GetBit(byteOffset + 4, bitOffset); kpDn[0].SetBit(byteOffset, bitOffset, bBit); } for (arrayOffset = 1; arrayOffset < 17; arrayOffset++) { // Shift left wrapped kpCn[arrayOffset].ShiftLeftWrapped(kpCn[arrayOffset - 1], DESTables.Shifts[arrayOffset - 1]); kpDn[arrayOffset].ShiftLeftWrapped(kpDn[arrayOffset - 1], DESTables.Shifts[arrayOffset - 1]); } // Create 17 keys Kn for (arrayOffset = 0; arrayOffset < 17; arrayOffset++) { // Loop through the bits int tableOffset; for (tableOffset = 0; tableOffset < 48; tableOffset++) { // Get address if bit permOffset = DESTables.PC2[tableOffset]; permOffset--; // Convert to byte and bit offsets byteOffset = BitAddressToByteOffset(permOffset, 7); bitOffset = BitAddressToBitOffset(permOffset, 7); // Get bit if (byteOffset < 4) { bBit = kpCn[arrayOffset].GetBit(byteOffset, bitOffset); } else { bBit = kpDn[arrayOffset].GetBit(byteOffset - 4, bitOffset); } // Set bit byteOffset = BitAddressToByteOffset(tableOffset, 6); bitOffset = BitAddressToBitOffset(tableOffset, 6); ftmp.GetAt(arrayOffset).SetBit(byteOffset, bitOffset, bBit); } } return(ftmp); }
public void Set(BLOCK8BYTE source) { // Copy source data to this this.Set(source._data, 0); }
protected KeySet ExpandKey(byte[] key, int offset) { // // Expand an 8 byte DES key into a set of permuted keys // // Declare return variable KeySet ftmp = new KeySet(); // Declaration of local variables int arrayOffset, permOffset, byteOffset, bitOffset; bool bBit; // Put key into an 8-bit block BLOCK8BYTE k = new BLOCK8BYTE(); k.Set(key, offset); // Permutate Kp with PC1 BLOCK8BYTE kp = new BLOCK8BYTE(); for (arrayOffset = 0; arrayOffset < DESTables.PC1.Length; arrayOffset++) { // Get permute offset permOffset = DESTables.PC1[arrayOffset]; permOffset--; // Get and set bit kp.SetBit( BitAddressToByteOffset(arrayOffset, 7), BitAddressToBitOffset(arrayOffset, 7), k.GetBit( BitAddressToByteOffset(permOffset, 8), BitAddressToBitOffset(permOffset, 8) ) ); } // Create 17 blocks of C and D from Kp BLOCK8BYTE[] kpCn = new BLOCK8BYTE[17]; BLOCK8BYTE[] kpDn = new BLOCK8BYTE[17]; for (arrayOffset = 0; arrayOffset < 17; arrayOffset++) { kpCn[arrayOffset] = new BLOCK8BYTE(); kpDn[arrayOffset] = new BLOCK8BYTE(); } for (arrayOffset = 0; arrayOffset < 32; arrayOffset++) { // Set bit in KpCn byteOffset = BitAddressToByteOffset(arrayOffset, 8); bitOffset = BitAddressToBitOffset(arrayOffset, 8); bBit = kp.GetBit(byteOffset, bitOffset); kpCn[0].SetBit(byteOffset, bitOffset, bBit); // Set bit in KpDn bBit = kp.GetBit(byteOffset + 4, bitOffset); kpDn[0].SetBit(byteOffset, bitOffset, bBit); } for (arrayOffset = 1; arrayOffset < 17; arrayOffset++) { // Shift left wrapped kpCn[arrayOffset].ShiftLeftWrapped(kpCn[arrayOffset - 1], DESTables.Shifts[arrayOffset - 1]); kpDn[arrayOffset].ShiftLeftWrapped(kpDn[arrayOffset - 1], DESTables.Shifts[arrayOffset - 1]); } // Create 17 keys Kn for (arrayOffset = 0; arrayOffset < 17; arrayOffset++) { // Loop through the bits int tableOffset; for (tableOffset = 0; tableOffset < 48; tableOffset++) { // Get address if bit permOffset = DESTables.PC2[tableOffset]; permOffset--; // Convert to byte and bit offsets byteOffset = BitAddressToByteOffset(permOffset, 7); bitOffset = BitAddressToBitOffset(permOffset, 7); // Get bit if (byteOffset < 4) bBit = kpCn[arrayOffset].GetBit(byteOffset, bitOffset); else bBit = kpDn[arrayOffset].GetBit(byteOffset - 4, bitOffset); // Set bit byteOffset = BitAddressToByteOffset(tableOffset, 6); bitOffset = BitAddressToBitOffset(tableOffset, 6); ftmp.GetAt(arrayOffset).SetBit(byteOffset, bitOffset, bBit); } } return ftmp; }
public void Xor(BLOCK8BYTE a, BLOCK8BYTE b) { // Set byte to A ^ B for (int offset = 0; offset < BYTE_LENGTH; offset++) _data[offset] = Convert.ToByte(a._data[offset] ^ b._data[offset]); }
public void Set(BLOCK8BYTE source) { // Copy source data to this this.Set(source._data, 0); }