Exemple #1
0
// NewCipher returns a new cipher.Block implementing the serpent block cipher.
// The key argument must be 128, 192 or 256 bit (16, 24, 32 byte).
func NewCipher(key []byte) (cipher.Block, error) {
	if k := len(key); k != 16 && k != 24 && k != 32 {
		return nil, crypto.KeySizeError(k)
	}
	s := &subkeys{}
	s.keySchedule(key)
	return s, nil
}
Exemple #2
0
// NewCipher returns a cipher.Block implementing the Threefish cipher.
// The length of the key must be 32, 64 or 128 byte.
// The length of the tweak must be TweakSize.
// The returned cipher implements:
//		- Threefish-256  - if len(key) = 32
//		- Threefish-512  - if len(key) = 64
// 		- Threefish-1024 - if len(key) = 128
func NewCipher(tweak *[TweakSize]byte, key []byte) (cipher.Block, error) {
	switch k := len(key); k {
	default:
		return nil, crypto.KeySizeError(k)
	case BlockSize256:
		return newCipher256(tweak, key), nil
	case BlockSize512:
		return newCipher512(tweak, key), nil
	case BlockSize1024:
		return newCipher1024(tweak, key), nil
	}
}
Exemple #3
0
// NewCipher returns a new cipher.Block implementing the camellia cipher.
// The key argument must be 128, 192 or 256 bit (16, 24, 32 byte).
func NewCipher(key []byte) (cipher.Block, error) {
	k := len(key)
	if k == 16 {
		c := new(blockCipher128)
		c.keySchedule(key)
		return c, nil
	}
	if k == 24 || k == 32 {
		c := new(blockCipher256)
		c.keySchedule(key)
		return c, nil
	}
	return nil, crypto.KeySizeError(k)
}
Exemple #4
0
// Configure takes the hash size and the BLAKE2b configuration and
// computes the 8 64-bit chain values. The conf is optional and can be nil,
// or must be a valid configuraton struct - otherwise a non-nil error is returned.
func Configure(hVal *[8]uint64, hashsize int, conf *Config) error {
	if hashsize <= 0 || hashsize > Size {
		return errors.New("illegal hash size " + strconv.Itoa(hashsize))
	}

	var key, salt, personal []byte
	if conf != nil {
		key = conf.Key
		salt = conf.Salt
		personal = conf.Personal
	}
	if k := len(key); k > Size {
		return crypto.KeySizeError(k)
	}
	if s := len(salt); s > 16 {
		return errors.New("illegal salt size " + strconv.Itoa(s))
	}
	if p := len(personal); p > 16 {
		return errors.New("illegal personalization size " + strconv.Itoa(p))
	}

	var p [BlockSize]byte
	p[0] = byte(hashsize)
	p[1] = byte(len(key))
	p[2] = 1
	p[3] = 1
	if len(salt) > 0 {
		copy(p[32:], salt)
	}
	if len(personal) > 0 {
		copy(p[48:], personal)
	}

	for i := range iv {
		j := i * 8
		v := uint64(p[j+0]) | uint64(p[j+1])<<8 | uint64(p[j+2])<<16 | uint64(p[j+3])<<24 |
			uint64(p[j+4])<<32 | uint64(p[j+5])<<40 | uint64(p[j+6])<<48 | uint64(p[j+7])<<56
		hVal[i] = iv[i] ^ v
	}
	return nil
}