mirror of
https://github.com/reactos/syzkaller.git
synced 2024-11-28 05:40:26 +00:00
461 lines
12 KiB
Go
461 lines
12 KiB
Go
// Copyright 2017 syzkaller project authors. All rights reserved.
|
|
// Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.
|
|
|
|
package linux
|
|
|
|
import (
|
|
"math/rand"
|
|
|
|
"github.com/google/syzkaller/prog"
|
|
)
|
|
|
|
func (arch *arch) generateSockaddrAlg(g *prog.Gen, typ0 prog.Type, old prog.Arg) (
|
|
arg prog.Arg, calls []*prog.Call) {
|
|
typ := typ0.(*prog.StructType)
|
|
family := g.GenerateArg(typ.Fields[0], &calls)
|
|
// There is very little point in generating feat/mask,
|
|
// because that can only fail otherwise correct bind.
|
|
feat := prog.MakeConstArg(typ.Fields[2], 0)
|
|
mask := prog.MakeConstArg(typ.Fields[3], 0)
|
|
if g.NOutOf(1, 1000) {
|
|
feat = g.GenerateArg(typ.Fields[2], &calls).(*prog.ConstArg)
|
|
mask = g.GenerateArg(typ.Fields[3], &calls).(*prog.ConstArg)
|
|
}
|
|
algType, algName := generateAlgName(g.Rand())
|
|
// Extend/truncate type/name to their fixed sizes.
|
|
algTypeData := fixedSizeData(algType, typ.Fields[1].Size())
|
|
algNameData := fixedSizeData(algName, typ.Fields[4].Size())
|
|
arg = prog.MakeGroupArg(typ, []prog.Arg{
|
|
family,
|
|
prog.MakeDataArg(typ.Fields[1], algTypeData),
|
|
feat,
|
|
mask,
|
|
prog.MakeDataArg(typ.Fields[4], algNameData),
|
|
})
|
|
return
|
|
}
|
|
|
|
func (arch *arch) generateAlgName(g *prog.Gen, typ prog.Type, old prog.Arg) (
|
|
arg prog.Arg, calls []*prog.Call) {
|
|
return generateAlgNameStruct(g, typ, allTypes[g.Rand().Intn(len(allTypes))].typ)
|
|
}
|
|
|
|
func (arch *arch) generateAlgAeadName(g *prog.Gen, typ prog.Type, old prog.Arg) (
|
|
arg prog.Arg, calls []*prog.Call) {
|
|
return generateAlgNameStruct(g, typ, ALG_AEAD)
|
|
}
|
|
|
|
func (arch *arch) generateAlgHashName(g *prog.Gen, typ prog.Type, old prog.Arg) (
|
|
arg prog.Arg, calls []*prog.Call) {
|
|
return generateAlgNameStruct(g, typ, ALG_HASH)
|
|
}
|
|
|
|
func (arch *arch) generateAlgBlkcipherhName(g *prog.Gen, typ prog.Type, old prog.Arg) (
|
|
arg prog.Arg, calls []*prog.Call) {
|
|
return generateAlgNameStruct(g, typ, ALG_BLKCIPHER)
|
|
}
|
|
|
|
func generateAlgNameStruct(g *prog.Gen, typ0 prog.Type, algTyp int) (arg prog.Arg, calls []*prog.Call) {
|
|
typ := typ0.(*prog.StructType)
|
|
algName := generateAlg(g.Rand(), algTyp)
|
|
algNameData := fixedSizeData(algName, typ.Fields[0].Size())
|
|
arg = prog.MakeGroupArg(typ, []prog.Arg{
|
|
prog.MakeDataArg(typ.Fields[0], algNameData),
|
|
})
|
|
return
|
|
}
|
|
|
|
func generateAlgName(rnd *rand.Rand) (string, string) {
|
|
typ := allTypes[rnd.Intn(len(allTypes))]
|
|
name := generateAlg(rnd, typ.typ)
|
|
return typ.name, name
|
|
}
|
|
|
|
func generateAlg(rnd *rand.Rand, typ int) string {
|
|
algs := allAlgs[typ]
|
|
alg := algs[rnd.Intn(len(algs))]
|
|
return generateAlgImpl(rnd, alg)
|
|
}
|
|
|
|
func generateAlgImpl(rnd *rand.Rand, alg algDesc) string {
|
|
args := ""
|
|
if len(alg.args) != 0 {
|
|
args += "("
|
|
for i, a := range alg.args {
|
|
if i != 0 {
|
|
args += ","
|
|
}
|
|
args += generateAlg(rnd, a)
|
|
}
|
|
args += ")"
|
|
}
|
|
return alg.name + args
|
|
}
|
|
|
|
func fixedSizeData(str string, sz uint64) []byte {
|
|
return append([]byte(str), make([]byte, sz)...)[:sz]
|
|
}
|
|
|
|
type algType struct {
|
|
name string
|
|
typ int
|
|
}
|
|
|
|
type algDesc struct {
|
|
name string
|
|
args []int
|
|
}
|
|
|
|
const (
|
|
ALG_CIPHER = iota
|
|
ALG_BLKCIPHER
|
|
ALG_AEAD
|
|
ALG_HASH
|
|
ALG_RNG
|
|
)
|
|
|
|
var allTypes = []algType{
|
|
{"aead", ALG_AEAD},
|
|
{"skcipher", ALG_BLKCIPHER},
|
|
{"hash", ALG_HASH},
|
|
{"rng", ALG_RNG},
|
|
}
|
|
|
|
var allAlgs = map[int][]algDesc{
|
|
ALG_AEAD: []algDesc{
|
|
// templates:
|
|
{"authencesn", []int{ALG_HASH, ALG_BLKCIPHER}},
|
|
{"authenc", []int{ALG_HASH, ALG_BLKCIPHER}},
|
|
{"rfc7539esp", []int{ALG_BLKCIPHER, ALG_HASH}},
|
|
{"rfc7539", []int{ALG_BLKCIPHER, ALG_HASH}},
|
|
{"rfc4543", []int{ALG_AEAD}},
|
|
{"rfc4106", []int{ALG_AEAD}},
|
|
{"pcrypt", []int{ALG_AEAD}},
|
|
{"rfc4309", []int{ALG_AEAD}},
|
|
{"gcm", []int{ALG_CIPHER}},
|
|
{"gcm_base", []int{ALG_BLKCIPHER, ALG_HASH}},
|
|
{"ccm", []int{ALG_CIPHER}},
|
|
{"ccm_base", []int{ALG_BLKCIPHER, ALG_HASH}},
|
|
{"echainiv", []int{ALG_AEAD}},
|
|
{"seqiv", []int{ALG_AEAD}},
|
|
|
|
// algorithms:
|
|
{"gcm(aes)", nil},
|
|
{"gcm_base(ctr(aes-aesni),ghash-generic)", nil},
|
|
{"generic-gcm-aesni", nil},
|
|
{"rfc4106(gcm(aes))", nil},
|
|
{"rfc4106-gcm-aesni", nil},
|
|
{"morus640", nil},
|
|
{"morus640-sse2", nil},
|
|
{"morus1280", nil},
|
|
{"morus1280-sse2", nil},
|
|
{"morus1280-avx2", nil},
|
|
{"aegis128", nil},
|
|
{"aegis128-aesni", nil},
|
|
{"aegis128l", nil},
|
|
{"aegis128l-aesni", nil},
|
|
{"aegis256", nil},
|
|
{"aegis256-aesni", nil},
|
|
},
|
|
ALG_BLKCIPHER: []algDesc{
|
|
// templates:
|
|
{"pcbc", []int{ALG_CIPHER}},
|
|
{"cbc", []int{ALG_CIPHER}},
|
|
{"cfb", []int{ALG_CIPHER}},
|
|
{"xts", []int{ALG_CIPHER}},
|
|
{"ctr", []int{ALG_CIPHER}},
|
|
{"lrw", []int{ALG_CIPHER}},
|
|
{"ecb", []int{ALG_CIPHER}},
|
|
{"kw", []int{ALG_CIPHER}},
|
|
{"cts", []int{ALG_BLKCIPHER}},
|
|
{"fpu", []int{ALG_BLKCIPHER}},
|
|
{"xts", []int{ALG_BLKCIPHER}},
|
|
{"lrw", []int{ALG_BLKCIPHER}},
|
|
{"rfc3686", []int{ALG_BLKCIPHER}},
|
|
{"cryptd", []int{ALG_BLKCIPHER}},
|
|
|
|
// algorithms:
|
|
{"cbc(aes)", nil},
|
|
{"cbc(aes-aesni)", nil},
|
|
{"chacha20", nil},
|
|
{"chacha20-simd", nil},
|
|
{"pcbc(aes)", nil},
|
|
{"pcbc-aes-aesni", nil},
|
|
{"fpu(pcbc(aes))", nil},
|
|
{"fpu(pcbc(aes-aesni))", nil},
|
|
{"pcbc(aes-aesni)", nil},
|
|
{"xts(aes)", nil},
|
|
{"xts-aes-aesni", nil},
|
|
{"ctr(aes)", nil},
|
|
{"ctr-aes-aesni", nil},
|
|
{"cbc-aes-aesni", nil},
|
|
{"ecb(aes)", nil},
|
|
{"ecb-aes-aesni", nil},
|
|
{"chacha20-generic", nil},
|
|
{"xts(serpent)", nil},
|
|
{"xts-serpent-avx2", nil},
|
|
{"lrw(serpent)", nil},
|
|
{"lrw-serpent-avx2", nil},
|
|
{"ctr(serpent)", nil},
|
|
{"ctr-serpent-avx2", nil},
|
|
{"cbc(serpent)", nil},
|
|
{"cbc-serpent-avx2", nil},
|
|
{"ecb(serpent)", nil},
|
|
{"ecb-serpent-avx2", nil},
|
|
{"xts(camellia)", nil},
|
|
{"xts-camellia-aesni-avx2", nil},
|
|
{"lrw(camellia)", nil},
|
|
{"lrw-camellia-aesni-avx2", nil},
|
|
{"ctr(camellia)", nil},
|
|
{"ctr-camellia-aesni-avx2", nil},
|
|
{"cbc(camellia)", nil},
|
|
{"cbc-camellia-aesni-avx2", nil},
|
|
{"ecb(camellia)", nil},
|
|
{"ecb-camellia-aesni-avx2", nil},
|
|
{"xts-serpent-avx", nil},
|
|
{"lrw-serpent-avx", nil},
|
|
{"ctr-serpent-avx", nil},
|
|
{"cbc-serpent-avx", nil},
|
|
{"ecb-serpent-avx", nil},
|
|
{"xts(twofish)", nil},
|
|
{"xts-twofish-avx", nil},
|
|
{"lrw(twofish)", nil},
|
|
{"lrw-twofish-avx", nil},
|
|
{"ctr(twofish)", nil},
|
|
{"ctr-twofish-avx", nil},
|
|
{"cbc(twofish)", nil},
|
|
{"cbc-twofish-avx", nil},
|
|
{"ecb(twofish)", nil},
|
|
{"ecb-twofish-avx", nil},
|
|
{"xts(cast6)", nil},
|
|
{"xts-cast6-avx", nil},
|
|
{"lrw(cast6)", nil},
|
|
{"lrw-cast6-avx", nil},
|
|
{"ctr(cast6)", nil},
|
|
{"ctr-cast6-avx", nil},
|
|
{"cbc(cast6)", nil},
|
|
{"cbc-cast6-avx", nil},
|
|
{"ecb(cast6)", nil},
|
|
{"ecb-cast6-avx", nil},
|
|
{"ctr(cast5)", nil},
|
|
{"ctr-cast5-avx", nil},
|
|
{"cbc(cast5)", nil},
|
|
{"cbc-cast5-avx", nil},
|
|
{"ecb(cast5)", nil},
|
|
{"ecb-cast5-avx", nil},
|
|
{"xts-camellia-aesni", nil},
|
|
{"lrw-camellia-aesni", nil},
|
|
{"ctr-camellia-aesni", nil},
|
|
{"cbc-camellia-aesni", nil},
|
|
{"ecb-camellia-aesni", nil},
|
|
{"xts-serpent-sse2", nil},
|
|
{"lrw-serpent-sse2", nil},
|
|
{"ctr-serpent-sse2", nil},
|
|
{"cbc-serpent-sse2", nil},
|
|
{"ecb-serpent-sse2", nil},
|
|
{"ctr(aes-aesni)", nil},
|
|
{"salsa20", nil},
|
|
{"salsa20-generic", nil},
|
|
{"ecb(arc4)", nil},
|
|
{"ecb(arc4)-generic", nil},
|
|
{"ecb(cipher_null)", nil},
|
|
{"ecb-cipher_null", nil},
|
|
{"salsa20-asm", nil},
|
|
{"xts-twofish-3way", nil},
|
|
{"lrw-twofish-3way", nil},
|
|
{"ctr-twofish-3way", nil},
|
|
{"cbc-twofish-3way", nil},
|
|
{"ecb-twofish-3way", nil},
|
|
{"ctr(blowfish)", nil},
|
|
{"ctr-blowfish-asm", nil},
|
|
{"cbc(blowfish)", nil},
|
|
{"cbc-blowfish-asm", nil},
|
|
{"ecb(blowfish)", nil},
|
|
{"ecb-blowfish-asm", nil},
|
|
{"xts-camellia-asm", nil},
|
|
{"lrw-camellia-asm", nil},
|
|
{"ctr-camellia-asm", nil},
|
|
{"cbc-camellia-asm", nil},
|
|
{"ecb-camellia-asm", nil},
|
|
{"ctr(des3_ede)", nil},
|
|
{"ctr-des3_ede-asm", nil},
|
|
{"cbc(des3_ede)", nil},
|
|
{"cbc-des3_ede-asm", nil},
|
|
{"ecb(des3_ede)", nil},
|
|
{"ecb-des3_ede-asm", nil},
|
|
},
|
|
ALG_CIPHER: []algDesc{
|
|
{"aes", nil},
|
|
{"aes-aesni", nil},
|
|
{"seed", nil},
|
|
{"seed-generic", nil},
|
|
{"anubis", nil},
|
|
{"anubis-generic", nil},
|
|
{"khazad", nil},
|
|
{"khazad-generic", nil},
|
|
{"xeta", nil},
|
|
{"xeta-generic", nil},
|
|
{"xtea", nil},
|
|
{"xtea-generic", nil},
|
|
{"tea", nil},
|
|
{"tea-generic", nil},
|
|
{"arc4", nil},
|
|
{"arc4-generic", nil},
|
|
{"cast6", nil},
|
|
{"cast6-generic", nil},
|
|
{"cast5", nil},
|
|
{"cast5-generic", nil},
|
|
{"camellia", nil},
|
|
{"camellia-generic", nil},
|
|
{"camellia-asm", nil},
|
|
{"tnepres", nil},
|
|
{"aes-fixed-time", nil},
|
|
{"aes-generic", nil},
|
|
{"tnepres-generic", nil},
|
|
{"serpent", nil},
|
|
{"serpent-generic", nil},
|
|
{"twofish", nil},
|
|
{"twofish-generic", nil},
|
|
{"twofish-asm", nil},
|
|
{"blowfish", nil},
|
|
{"blowfish-generic", nil},
|
|
{"blowfish-asm", nil},
|
|
{"fcrypt", nil},
|
|
{"fcrypt-generic", nil},
|
|
{"des3_ede", nil},
|
|
{"des3_ede-generic", nil},
|
|
{"des3_ede-asm", nil},
|
|
{"des", nil},
|
|
{"des-generic", nil},
|
|
{"cipher_null", nil},
|
|
{"cipher_null-generic", nil},
|
|
{"aes-asm", nil},
|
|
},
|
|
ALG_HASH: []algDesc{
|
|
// templates:
|
|
{"cmac", []int{ALG_CIPHER}},
|
|
{"cbcmac", []int{ALG_CIPHER}},
|
|
{"xcbc", []int{ALG_CIPHER}},
|
|
{"vmac", []int{ALG_CIPHER}},
|
|
{"hmac", []int{ALG_HASH}},
|
|
{"mcryptd", []int{ALG_HASH}},
|
|
{"cryptd", []int{ALG_HASH}},
|
|
|
|
// algorithms:
|
|
{"sha512", nil},
|
|
{"sha512_mb", nil},
|
|
{"sha256", nil},
|
|
{"sha256_mb", nil},
|
|
{"sha1", nil},
|
|
{"sha1_mb", nil},
|
|
{"ghash", nil},
|
|
{"ghash-clmulni", nil},
|
|
{"md4", nil},
|
|
{"md4-generic", nil},
|
|
{"md5", nil},
|
|
{"md5-generic", nil},
|
|
{"ghash-generic", nil},
|
|
{"crct10dif", nil},
|
|
{"crct10dif-generic", nil},
|
|
{"crct10dif-pclmul", nil},
|
|
{"crc32", nil},
|
|
{"crc32-generic", nil},
|
|
{"crc32c", nil},
|
|
{"crc32c-generic", nil},
|
|
{"michael_mic", nil},
|
|
{"michael_mic-generic", nil},
|
|
{"poly1305", nil},
|
|
{"poly1305-generic", nil},
|
|
{"tgr128", nil},
|
|
{"tgr128-generic", nil},
|
|
{"tgr160", nil},
|
|
{"tgr160-generic", nil},
|
|
{"tgr192", nil},
|
|
{"tgr192-generic", nil},
|
|
{"wp256", nil},
|
|
{"wp256-generic", nil},
|
|
{"wp384", nil},
|
|
{"wp384-generic", nil},
|
|
{"wp512", nil},
|
|
{"wp512-generic", nil},
|
|
{"sm3", nil},
|
|
{"sm3-generic", nil},
|
|
{"sm4", nil},
|
|
{"sm4-generic", nil},
|
|
{"speck128", nil},
|
|
{"speck128-generic", nil},
|
|
{"speck64", nil},
|
|
{"speck64-generic", nil},
|
|
{"sha3-512", nil},
|
|
{"sha3-512-generic", nil},
|
|
{"sha3-384", nil},
|
|
{"sha3-384-generic", nil},
|
|
{"sha3-256", nil},
|
|
{"sha3-256-generic", nil},
|
|
{"sha3-224", nil},
|
|
{"sha3-224-generic", nil},
|
|
{"sha384", nil},
|
|
{"sha384-generic", nil},
|
|
{"sha512-generic", nil},
|
|
{"sha224", nil},
|
|
{"sha224-generic", nil},
|
|
{"sha256-generic", nil},
|
|
{"sha1-generic", nil},
|
|
{"rmd320", nil},
|
|
{"rmd320-generic", nil},
|
|
{"rmd256", nil},
|
|
{"rmd256-generic", nil},
|
|
{"rmd160", nil},
|
|
{"rmd160-generic", nil},
|
|
{"rmd128", nil},
|
|
{"rmd128-generic", nil},
|
|
{"digest_null", nil},
|
|
{"digest_null-generic", nil},
|
|
{"poly1305-simd", nil},
|
|
{"sha384-avx2", nil},
|
|
{"sha512-avx2", nil},
|
|
{"sha384-avx", nil},
|
|
{"sha512-avx", nil},
|
|
{"sha384-ssse3", nil},
|
|
{"sha512-ssse3", nil},
|
|
{"sha224-avx2", nil},
|
|
{"sha256-avx2", nil},
|
|
{"sha224-avx", nil},
|
|
{"sha256-avx", nil},
|
|
{"sha224-ssse3", nil},
|
|
{"sha256-ssse3", nil},
|
|
{"crc32-pclmul", nil},
|
|
{"sha1-avx2", nil},
|
|
{"sha1-avx", nil},
|
|
{"sha1-ssse3", nil},
|
|
{"crc32c-intel", nil},
|
|
},
|
|
ALG_RNG: []algDesc{
|
|
{"stdrng", nil},
|
|
{"ansi_cprng", nil},
|
|
{"jitterentropy_rng", nil},
|
|
{"drbg_nopr_hmac_sha256", nil},
|
|
{"drbg_nopr_hmac_sha512", nil},
|
|
{"drbg_nopr_hmac_sha384", nil},
|
|
{"drbg_nopr_hmac_sha1", nil},
|
|
{"drbg_nopr_sha256", nil},
|
|
{"drbg_nopr_sha512", nil},
|
|
{"drbg_nopr_sha384", nil},
|
|
{"drbg_nopr_sha1", nil},
|
|
{"drbg_nopr_ctr_aes256", nil},
|
|
{"drbg_nopr_ctr_aes192", nil},
|
|
{"drbg_nopr_ctr_aes128", nil},
|
|
{"drbg_pr_hmac_sha256", nil},
|
|
{"drbg_pr_hmac_sha512", nil},
|
|
{"drbg_pr_hmac_sha384", nil},
|
|
{"drbg_pr_hmac_sha1", nil},
|
|
{"drbg_pr_sha256", nil},
|
|
{"drbg_pr_sha512", nil},
|
|
{"drbg_pr_sha384", nil},
|
|
{"drbg_pr_sha1", nil},
|
|
{"drbg_pr_ctr_aes256", nil},
|
|
{"drbg_pr_ctr_aes192", nil},
|
|
{"drbg_pr_ctr_aes128", nil},
|
|
},
|
|
}
|