e465. converting a 56-bit value to a des key.txt

这里面包含了一百多个JAVA源文件

The DES encrypter/decrypter requires a 64-bit key where only 56-bit are significant. The other 8-bit are parity bits used to ensure that the key has not been corrupted. To make the 64-bit key, the 56-bit value is broken up into 7-bit chunks. Each 7-bit chunk is moved into an 8-bit slot taking up the most significant bit positions. The least significant bit (the parity bit) is set to either 1 or 0 in order to make the quantity of 1 bits in the byte an odd number. 
This example implements a method to convert a 56-bit value into a valid DES key. Such a method could be used to convert a 7-character string password to a valid DES key. 

See also e462 Encrypting a String with DES. 

    // Takes a 7-byte quantity and returns a valid 8-byte DES key.
    // The input and output bytes are big-endian, where the most significant
    // byte is in element 0.
    public static byte[] addParity(byte[] in) {
        byte[] result = new byte[8];
    
        // Keeps track of the bit position in the result
        int resultIx = 1;
    
        // Used to keep track of the number of 1 bits in each 7-bit chunk
        int bitCount = 0;
    
        // Process each of the 56 bits
        for (int i=0; i<56; i++) {
            // Get the bit at bit position i
            boolean bit = (in[6-i/8]&(1<<(i%8))) > 0;
    
            // If set, set the corresponding bit in the result
            if (bit) {
                result[7-resultIx/8] |= (1<<(resultIx%8))&0xFF;
                bitCount++;
            }
    
            // Set the parity bit after every 7 bits
            if ((i+1) % 7 == 0) {
                if (bitCount % 2 == 0) {
                    // Set low-order bit (parity bit) if bit count is even
                    result[7-resultIx/8] |= 1;
                }
                resultIx++;
                bitCount = 0;
            }
            resultIx++;
        }
        return result;
    }

    // Get the 56-bit value
    byte[] raw = new byte[]{0x01, 0x72, 0x43, 0x3E, 0x1C, 0x7A, 0x55};
    byte[] keyBytes = addParity(raw);
    
    // You can check that the parity has been set properly
    try {
        boolean b = DESKeySpec.isParityAdjusted(keyBytes, 0);
    } catch (java.security.InvalidKeyException e) {
        // The DES is invalid
    }
    
    // Convert the bytes into a SecretKey suitable for use by Cipher
    SecretKey key = new SecretKeySpec(keyBytes, "DES");