package des

Import Path
	crypto/des (on go.dev)

Dependency Relation
	imports 5 packages, and imported by 2 packages

Involved Source Files

	      block.go
	      cipher.go
	   #d const.go
		Package des implements the Data Encryption Standard (DES) and the
		Triple Data Encryption Algorithm (TDEA) as defined
		in U.S. Federal Information Processing Standards Publication 46-3.

		DES is cryptographically broken and should not be used for secure
		applications.
Code Examples

	NewTripleDESCipher
		package main
		
		import (
			"crypto/des"
		)
		
		func main() {
			// NewTripleDESCipher can also be used when EDE2 is required by
			// duplicating the first 8 bytes of the 16-byte key.
			ede2Key := []byte("example key 1234")
		
			var tripleDESKey []byte
			tripleDESKey = append(tripleDESKey, ede2Key[:16]...)
			tripleDESKey = append(tripleDESKey, ede2Key[:8]...)
		
			_, err := des.NewTripleDESCipher(tripleDESKey)
			if err != nil {
				panic(err)
			}
		
			// See crypto/cipher for how to use a cipher.Block for encryption and
			// decryption.
		}


Package-Level Type Names (total 3, in which 1 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type KeySizeError int (basic type)

		Methods (only one, which is exported)
			( T) Error() string
		Implements (at least one exported)
			 T : error

	/* 2 unexporteds ... *//* 2 unexporteds: */
	 type desCipher (struct)
		desCipher is an instance of DES encryption.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			subkeys [16]uint64
		Methods (total 4, in which 3 are exported)
			(*T) BlockSize() int
			(*T) Decrypt(dst, src []byte)
			(*T) Encrypt(dst, src []byte)
			/* one unexported ... *//* one unexported: */
			(*T) generateSubkeys(keyBytes []byte)
				creates 16 56-bit subkeys from the original key

		Implements (at least one exported)
			*T : crypto/cipher.Block

	 type tripleDESCipher (struct)
		A tripleDESCipher is an instance of TripleDES encryption.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			cipher1 desCipher
			cipher2 desCipher
			cipher3 desCipher
		Methods (total 3, all are exported)
			(*T) BlockSize() int
			(*T) Decrypt(dst, src []byte)
			(*T) Encrypt(dst, src []byte)
		Implements (at least one exported)
			*T : crypto/cipher.Block


Package-Level Functions (total 12, in which 2 are exported)

	 func NewCipher(key []byte) (cipher.Block, error)
		NewCipher creates and returns a new cipher.Block.

	 func NewTripleDESCipher(key []byte) (cipher.Block, error)
		NewTripleDESCipher creates and returns a new cipher.Block.

	/* 10 unexporteds ... *//* 10 unexporteds: */
	 func cryptBlock(subkeys []uint64, dst, src []byte, decrypt bool)
	 func decryptBlock(subkeys []uint64, dst, src []byte)
		Decrypt one block from src into dst, using the subkeys.

	 func encryptBlock(subkeys []uint64, dst, src []byte)
		Encrypt one block from src into dst, using the subkeys.

	 func feistel(l, r uint32, k0, k1 uint64) (lout, rout uint32)
		DES Feistel function. feistelBox must be initialized via
		feistelBoxOnce.Do(initFeistelBox) first.

	 func initFeistelBox()
	 func ksRotate(in uint32) (out []uint32)
		creates 16 28-bit blocks rotated according
		to the rotation schedule

	 func permuteBlock(src uint64, permutation []uint8) (block uint64)
		general purpose function to perform DES block permutations

	 func permuteFinalBlock(block uint64) uint64
		permuteInitialBlock is equivalent to the permutation defined
		by finalPermutation.

	 func permuteInitialBlock(block uint64) uint64
		permuteInitialBlock is equivalent to the permutation defined
		by initialPermutation.

	 func unpack(x uint64) uint64
		Expand 48-bit input to 64-bit, with each 6-bit block padded by extra two bits at the top.
		By doing so, we can have the input blocks (four bits each), and the key blocks (six bits each) well-aligned without
		extra shifts/rotations for alignments.


Package-Level Variables (total 10, none are exported)

	/* 10 unexporteds ... *//* 10 unexporteds: */
	  var expansionFunction [48]byte
		Used to expand an input block of 32 bits, producing an output block of 48
		bits.

	  var feistelBox [8][64]uint32
		feistelBox[s][16*i+j] contains the output of permutationFunction
		for sBoxes[s][i][j] << 4*(7-s)

	  var feistelBoxOnce sync.Once
	  var finalPermutation [64]byte
		Used to perform a final permutation of a 4-bit preoutput block. This is the
		inverse of initialPermutation

	  var initialPermutation [64]byte
		Used to perform an initial permutation of a 64-bit input block.

	  var ksRotations [16]uint8
		Size of left rotation per round in each half of the key schedule

	  var permutationFunction [32]byte
		Yields a 32-bit output from a 32-bit input

	  var permutedChoice1 [56]byte
		Used in the key schedule to select 56 bits
		from a 64-bit input.

	  var permutedChoice2 [48]byte
		Used in the key schedule to produce each subkey by selecting 48 bits from
		the 56-bit input

	  var sBoxes [8][4][16]uint8
		8 S-boxes composed of 4 rows and 16 columns
		Used in the DES cipher function


Package-Level Constants (only one, which is exported)

	const BlockSize = 8
		The DES block size in bytes.

The pages are generated with Golds v0.4.2. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.