Page MenuHomeFreeBSD
Differential D44925

linuxkpi: Add linuxkpi_video module
ClosedPublic
Actions

Authored by manu on Apr 24 2024, 8:16 AM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Apr 15, 9:49 PM
Unknown Object (File)
Mon, Apr 14, 1:54 AM
Unknown Object (File)
Sat, Apr 12, 3:53 PM
Unknown Object (File)
Sat, Apr 12, 7:18 AM
Unknown Object (File)
Jan 27 2025, 12:01 PM
Unknown Object (File)
Jan 22 2025, 11:28 PM
Unknown Object (File)
Jan 9 2025, 10:26 AM
Unknown Object (File)
Nov 25 2024, 4:42 PM
View All Files
Subscribers
bz
emaste
imp
linuxkpi

Details

Reviewers
wulf
dumbbell
bz
Group Reviewers
linuxkpi
Commits
rG5080cf0846df: linuxkpi: Add linuxkpi_video module
rG11d79c4756b7: linuxkpi: Add linuxkpi_video module
Summary

This contain the hdmi code and the aperture code like in linux.

Obtained from: drm-kmod
Sponsored by: Beckhoff Automation GmbH & Co. KG

Diff Detail

Repository
rG FreeBSD src repository
Lint
Lint Skipped
Unit
Tests Skipped
Build Status
Buildable 57322
Build 54210: arc lint + arc unit

Event Timeline

manu created this revision.Apr 24 2024, 8:16 AM
Herald added subscribers: linuxkpi, emaste, imp. · View Herald TranscriptApr 24 2024, 8:16 AM
manu requested review of this revision.Apr 24 2024, 8:16 AM
Harbormaster completed remote builds in B57322: Diff 137597.Apr 24 2024, 8:16 AM
manu added reviewers: linuxkpi, wulf, dumbbell.Apr 24 2024, 8:16 AM
manu added a parent revision: D44926: linuxkpi: hdmi: Split the module declaration to a new file.
bz added a subscriber: bz.EditedApr 25 2024, 10:48 PM

What is going to happen to sys/modules/linuxkpi_hdmi then? They both compile in linux_hdmi.c (okay, saw the other revision) We do not get symbol clashes?

Also if the two MIT-licensed files are obtained from Linux (or elsewhere) it would be good to mention it and from which OS/Version/Hash.

Otherwise I am really happy to see the linuxkpi_*.c file in common/src given I keep meaning to say that we should rename them all away from linux_?

manu added a comment.Apr 26 2024, 5:06 AM
In D44925#1025028, @bz wrote:

What is going to happen to sys/modules/linuxkpi_hdmi then? They both compile in linux_hdmi.c (okay, saw the other revision) We do not get symbol clashes?

It will die.

Currently only 5.15 uses linuxkpi_hdmi, 6.1 switched to linuxkpi_video.

Also if the two MIT-licensed files are obtained from Linux (or elsewhere) it would be good to mention it and from which OS/Version/Hash.

Otherwise I am really happy to see the linuxkpi_*.c file in common/src given I keep meaning to say that we should rename them all away from linux_?

I can do the rename.

bz added a comment.Apr 26 2024, 5:16 AM

Otherwise I am really happy to see the linuxkpi_*.c file in common/src given I keep meaning to say that we should rename them all away from linux_?

I can do the rename.

I'd suggest to pick a moment when people have little outstanding work at some point in the future; the trouble (as always) simply will be MFCing then... Let's take that separately.

bz accepted this revision.Apr 26 2024, 5:17 AM
This revision is now accepted and ready to land.Apr 26 2024, 5:17 AM
Closed by commit rG11d79c4756b7: linuxkpi: Add linuxkpi_video module (authored by manu). · Explain WhyApr 30 2024, 5:59 AM
This revision was automatically updated to reflect the committed changes.
manu added a commit: rG11d79c4756b7: linuxkpi: Add linuxkpi_video module.
manu added a commit: rG5080cf0846df: linuxkpi: Add linuxkpi_video module.Jun 4 2024, 11:20 AM

Revision Contents
Changeset List

PathSize
sys/
compat/
linuxkpi/
common/
include/
linux/
58 lines
src/
365 lines
7 lines
modules/
1 line
linuxkpi_video/
15 lines

Diff 137597

View Options

sys/compat/linuxkpi/common/include/linux/aperture.h

Show First 20 Lines • Show All 247 Lines • ▼ Show 20 Lines
} }
static int static int
aesni_probesession(device_t dev, const struct crypto_session_params *csp) aesni_probesession(device_t dev, const struct crypto_session_params *csp)
{ {
struct aesni_softc *sc; struct aesni_softc *sc;
sc = device_get_softc(dev); sc = device_get_softc(dev);
if (csp->csp_flags != 0) if ((csp->csp_flags & ~(CSP_F_SEPARATE_OUTPUT)) != 0)
return (EINVAL); return (EINVAL);
switch (csp->csp_mode) { switch (csp->csp_mode) {
case CSP_MODE_DIGEST: case CSP_MODE_DIGEST:
if (!aesni_auth_supported(sc, csp)) if (!aesni_auth_supported(sc, csp))
return (EINVAL); return (EINVAL);
break; break;
case CSP_MODE_CIPHER: case CSP_MODE_CIPHER:
if (!aesni_cipher_supported(sc, csp)) if (!aesni_cipher_supported(sc, csp))
▲ Show 20 Lines • Show All 407 Lines • ▼ Show 20 Linesaesni_cipher_process(struct aesni_session *ses, struct cryptop *crp)
} }
return (error); return (error);
} }
static int static int
aesni_cipher_crypt(struct aesni_session *ses, struct cryptop *crp, aesni_cipher_crypt(struct aesni_session *ses, struct cryptop *crp,
const struct crypto_session_params *csp) const struct crypto_session_params *csp)
{ {
uint8_t iv[AES_BLOCK_LEN], tag[GMAC_DIGEST_LEN], *buf, *authbuf; uint8_t iv[AES_BLOCK_LEN], tag[GMAC_DIGEST_LEN];
uint8_t *authbuf, *buf, *outbuf;
int error; int error;
bool encflag, allocated, authallocated; bool encflag, allocated, authallocated, outallocated, outcopy;
buf = aesni_cipher_alloc(crp, crp->crp_payload_start, buf = aesni_cipher_alloc(crp, crp->crp_payload_start,
crp->crp_payload_length, &allocated); crp->crp_payload_length, &allocated);
if (buf == NULL) if (buf == NULL)
return (ENOMEM); return (ENOMEM);
outallocated = false;
authallocated = false; authallocated = false;
authbuf = NULL; authbuf = NULL;
if (csp->csp_cipher_alg == CRYPTO_AES_NIST_GCM_16 || if (csp->csp_cipher_alg == CRYPTO_AES_NIST_GCM_16 ||
csp->csp_cipher_alg == CRYPTO_AES_CCM_16) { csp->csp_cipher_alg == CRYPTO_AES_CCM_16) {
authbuf = aesni_cipher_alloc(crp, crp->crp_aad_start, authbuf = aesni_cipher_alloc(crp, crp->crp_aad_start,
crp->crp_aad_length, &authallocated); crp->crp_aad_length, &authallocated);
if (authbuf == NULL) { if (authbuf == NULL) {
error = ENOMEM; error = ENOMEM;
goto out; goto out;
} }
} }
if (CRYPTO_HAS_OUTPUT_BUFFER(crp)) {
outbuf = crypto_buffer_contiguous_subsegment(&crp->crp_obuf,
crp->crp_payload_output_start, crp->crp_payload_length);
if (outbuf == NULL) {
outcopy = true;
if (allocated)
outbuf = buf;
else {
outbuf = malloc(crp->crp_payload_length,
M_AESNI, M_NOWAIT);
if (outbuf == NULL) {
error = ENOMEM;
goto out;
}
outallocated = true;
}
} else
outcopy = false;
} else {
outbuf = buf;
outcopy = allocated;
}
error = 0; error = 0;
encflag = CRYPTO_OP_IS_ENCRYPT(crp->crp_op); encflag = CRYPTO_OP_IS_ENCRYPT(crp->crp_op);
if (crp->crp_cipher_key != NULL) if (crp->crp_cipher_key != NULL)
aesni_cipher_setup_common(ses, csp, crp->crp_cipher_key, aesni_cipher_setup_common(ses, csp, crp->crp_cipher_key,
csp->csp_cipher_klen); csp->csp_cipher_klen);
crypto_read_iv(crp, iv); crypto_read_iv(crp, iv);
switch (csp->csp_cipher_alg) { switch (csp->csp_cipher_alg) {
case CRYPTO_AES_CBC: case CRYPTO_AES_CBC:
if (encflag) if (encflag)
aesni_encrypt_cbc(ses->rounds, ses->enc_schedule, aesni_encrypt_cbc(ses->rounds, ses->enc_schedule,
crp->crp_payload_length, buf, buf, iv); crp->crp_payload_length, buf, outbuf, iv);
else else {
if (buf != outbuf)
memcpy(outbuf, buf, crp->crp_payload_length);
aesni_decrypt_cbc(ses->rounds, ses->dec_schedule, aesni_decrypt_cbc(ses->rounds, ses->dec_schedule,
crp->crp_payload_length, buf, iv); crp->crp_payload_length, outbuf, iv);
}
break; break;
case CRYPTO_AES_ICM: case CRYPTO_AES_ICM:
/* encryption & decryption are the same */ /* encryption & decryption are the same */
aesni_encrypt_icm(ses->rounds, ses->enc_schedule, aesni_encrypt_icm(ses->rounds, ses->enc_schedule,
crp->crp_payload_length, buf, buf, iv); crp->crp_payload_length, buf, outbuf, iv);
break; break;
case CRYPTO_AES_XTS: case CRYPTO_AES_XTS:
if (encflag) if (encflag)
aesni_encrypt_xts(ses->rounds, ses->enc_schedule, aesni_encrypt_xts(ses->rounds, ses->enc_schedule,
ses->xts_schedule, crp->crp_payload_length, buf, ses->xts_schedule, crp->crp_payload_length, buf,
buf, iv); outbuf, iv);
else else
aesni_decrypt_xts(ses->rounds, ses->dec_schedule, aesni_decrypt_xts(ses->rounds, ses->dec_schedule,
ses->xts_schedule, crp->crp_payload_length, buf, ses->xts_schedule, crp->crp_payload_length, buf,
buf, iv); outbuf, iv);
break; break;
case CRYPTO_AES_NIST_GCM_16: case CRYPTO_AES_NIST_GCM_16:
if (encflag) { if (encflag) {
memset(tag, 0, sizeof(tag)); memset(tag, 0, sizeof(tag));
AES_GCM_encrypt(buf, buf, authbuf, iv, tag, AES_GCM_encrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds); csp->csp_ivlen, ses->enc_schedule, ses->rounds);
crypto_copyback(crp, crp->crp_digest_start, sizeof(tag), crypto_copyback(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
} else { } else {
crypto_copydata(crp, crp->crp_digest_start, sizeof(tag), crypto_copydata(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
if (!AES_GCM_decrypt(buf, buf, authbuf, iv, tag, if (!AES_GCM_decrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds)) csp->csp_ivlen, ses->enc_schedule, ses->rounds))
error = EBADMSG; error = EBADMSG;
} }
break; break;
case CRYPTO_AES_CCM_16: case CRYPTO_AES_CCM_16:
if (encflag) { if (encflag) {
memset(tag, 0, sizeof(tag)); memset(tag, 0, sizeof(tag));
AES_CCM_encrypt(buf, buf, authbuf, iv, tag, AES_CCM_encrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds); csp->csp_ivlen, ses->enc_schedule, ses->rounds);
crypto_copyback(crp, crp->crp_digest_start, sizeof(tag), crypto_copyback(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
} else { } else {
crypto_copydata(crp, crp->crp_digest_start, sizeof(tag), crypto_copydata(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
if (!AES_CCM_decrypt(buf, buf, authbuf, iv, tag, if (!AES_CCM_decrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds)) csp->csp_ivlen, ses->enc_schedule, ses->rounds))
error = EBADMSG; error = EBADMSG;
} }
break; break;
} }
if (allocated && error == 0) if (outcopy && error == 0)
crypto_copyback(crp, crp->crp_payload_start, crypto_copyback(crp, CRYPTO_HAS_OUTPUT_BUFFER(crp) ?
crp->crp_payload_length, buf); crp->crp_payload_output_start : crp->crp_payload_start,
crp->crp_payload_length, outbuf);
out: out:
if (allocated) { if (allocated) {
explicit_bzero(buf, crp->crp_payload_length); explicit_bzero(buf, crp->crp_payload_length);
free(buf, M_AESNI); free(buf, M_AESNI);
} }
if (authallocated) { if (authallocated) {
explicit_bzero(authbuf, crp->crp_aad_length); explicit_bzero(authbuf, crp->crp_aad_length);
free(authbuf, M_AESNI); free(authbuf, M_AESNI);
} }
if (outallocated) {
explicit_bzero(outbuf, crp->crp_payload_length);
free(outbuf, M_AESNI);
}
return (error); return (error);
} }
static int static int
aesni_cipher_mac(struct aesni_session *ses, struct cryptop *crp, aesni_cipher_mac(struct aesni_session *ses, struct cryptop *crp,
const struct crypto_session_params *csp) const struct crypto_session_params *csp)
{ {
union { union {
Show All 19 Lines for (i = 0; i < keylen; i++)
hmac_key[i] = key[i] ^ HMAC_IPAD_VAL; hmac_key[i] = key[i] ^ HMAC_IPAD_VAL;
for (i = keylen; i < sizeof(hmac_key); i++) for (i = keylen; i < sizeof(hmac_key); i++)
hmac_key[i] = 0 ^ HMAC_IPAD_VAL; hmac_key[i] = 0 ^ HMAC_IPAD_VAL;
ses->hash_update(&sctx, hmac_key, sizeof(hmac_key)); ses->hash_update(&sctx, hmac_key, sizeof(hmac_key));
crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length, crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int), ses->hash_update),
&sctx); &sctx);
if (CRYPTO_HAS_OUTPUT_BUFFER(crp) &&
CRYPTO_OP_IS_ENCRYPT(crp->crp_op))
crypto_apply_buf(&crp->crp_obuf,
crp->crp_payload_output_start,
crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int),
ses->hash_update), &sctx);
else
crypto_apply(crp, crp->crp_payload_start, crypto_apply(crp, crp->crp_payload_start,
crp->crp_payload_length, crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int),
&sctx); ses->hash_update), &sctx);
ses->hash_finalize(res, &sctx); ses->hash_finalize(res, &sctx);
/* Outer hash: (K ^ OPAD) || inner hash */ /* Outer hash: (K ^ OPAD) || inner hash */
ses->hash_init(&sctx); ses->hash_init(&sctx);
for (i = 0; i < keylen; i++) for (i = 0; i < keylen; i++)
hmac_key[i] = key[i] ^ HMAC_OPAD_VAL; hmac_key[i] = key[i] ^ HMAC_OPAD_VAL;
for (i = keylen; i < sizeof(hmac_key); i++) for (i = keylen; i < sizeof(hmac_key); i++)
hmac_key[i] = 0 ^ HMAC_OPAD_VAL; hmac_key[i] = 0 ^ HMAC_OPAD_VAL;
ses->hash_update(&sctx, hmac_key, sizeof(hmac_key)); ses->hash_update(&sctx, hmac_key, sizeof(hmac_key));
ses->hash_update(&sctx, res, ses->hash_len); ses->hash_update(&sctx, res, ses->hash_len);
ses->hash_finalize(res, &sctx); ses->hash_finalize(res, &sctx);
} else { } else {
ses->hash_init(&sctx); ses->hash_init(&sctx);
crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length, crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int), ses->hash_update),
&sctx); &sctx);
if (CRYPTO_HAS_OUTPUT_BUFFER(crp) &&
CRYPTO_OP_IS_ENCRYPT(crp->crp_op))
crypto_apply_buf(&crp->crp_obuf,
crp->crp_payload_output_start,
crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int),
ses->hash_update), &sctx);
else
crypto_apply(crp, crp->crp_payload_start, crypto_apply(crp, crp->crp_payload_start,
crp->crp_payload_length, crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int),
&sctx); ses->hash_update), &sctx);
ses->hash_finalize(res, &sctx); ses->hash_finalize(res, &sctx);
} }
if (crp->crp_op & CRYPTO_OP_VERIFY_DIGEST) { if (crp->crp_op & CRYPTO_OP_VERIFY_DIGEST) {
crypto_copydata(crp, crp->crp_digest_start, ses->mlen, res2); crypto_copydata(crp, crp->crp_digest_start, ses->mlen, res2);
if (timingsafe_bcmp(res, res2, ses->mlen) != 0) if (timingsafe_bcmp(res, res2, ses->mlen) != 0)
return (EBADMSG); return (EBADMSG);
} else } else
crypto_copyback(crp, crp->crp_digest_start, ses->mlen, res); crypto_copyback(crp, crp->crp_digest_start, ses->mlen, res);
return (0); return (0);
} }
View Options

sys/compat/linuxkpi/common/src/linux_aperture.c

Show First 20 Lines • Show All 247 Lines • ▼ Show 20 Lines
} }
static int static int
aesni_probesession(device_t dev, const struct crypto_session_params *csp) aesni_probesession(device_t dev, const struct crypto_session_params *csp)
{ {
struct aesni_softc *sc; struct aesni_softc *sc;
sc = device_get_softc(dev); sc = device_get_softc(dev);
if (csp->csp_flags != 0) if ((csp->csp_flags & ~(CSP_F_SEPARATE_OUTPUT)) != 0)
return (EINVAL); return (EINVAL);
switch (csp->csp_mode) { switch (csp->csp_mode) {
case CSP_MODE_DIGEST: case CSP_MODE_DIGEST:
if (!aesni_auth_supported(sc, csp)) if (!aesni_auth_supported(sc, csp))
return (EINVAL); return (EINVAL);
break; break;
case CSP_MODE_CIPHER: case CSP_MODE_CIPHER:
if (!aesni_cipher_supported(sc, csp)) if (!aesni_cipher_supported(sc, csp))
▲ Show 20 Lines • Show All 407 Lines • ▼ Show 20 Linesaesni_cipher_process(struct aesni_session *ses, struct cryptop *crp)
} }
return (error); return (error);
} }
static int static int
aesni_cipher_crypt(struct aesni_session *ses, struct cryptop *crp, aesni_cipher_crypt(struct aesni_session *ses, struct cryptop *crp,
const struct crypto_session_params *csp) const struct crypto_session_params *csp)
{ {
uint8_t iv[AES_BLOCK_LEN], tag[GMAC_DIGEST_LEN], *buf, *authbuf; uint8_t iv[AES_BLOCK_LEN], tag[GMAC_DIGEST_LEN];
uint8_t *authbuf, *buf, *outbuf;
int error; int error;
bool encflag, allocated, authallocated; bool encflag, allocated, authallocated, outallocated, outcopy;
buf = aesni_cipher_alloc(crp, crp->crp_payload_start, buf = aesni_cipher_alloc(crp, crp->crp_payload_start,
crp->crp_payload_length, &allocated); crp->crp_payload_length, &allocated);
if (buf == NULL) if (buf == NULL)
return (ENOMEM); return (ENOMEM);
outallocated = false;
authallocated = false; authallocated = false;
authbuf = NULL; authbuf = NULL;
if (csp->csp_cipher_alg == CRYPTO_AES_NIST_GCM_16 || if (csp->csp_cipher_alg == CRYPTO_AES_NIST_GCM_16 ||
csp->csp_cipher_alg == CRYPTO_AES_CCM_16) { csp->csp_cipher_alg == CRYPTO_AES_CCM_16) {
authbuf = aesni_cipher_alloc(crp, crp->crp_aad_start, authbuf = aesni_cipher_alloc(crp, crp->crp_aad_start,
crp->crp_aad_length, &authallocated); crp->crp_aad_length, &authallocated);
if (authbuf == NULL) { if (authbuf == NULL) {
error = ENOMEM; error = ENOMEM;
goto out; goto out;
} }
} }
if (CRYPTO_HAS_OUTPUT_BUFFER(crp)) {
outbuf = crypto_buffer_contiguous_subsegment(&crp->crp_obuf,
crp->crp_payload_output_start, crp->crp_payload_length);
if (outbuf == NULL) {
outcopy = true;
if (allocated)
outbuf = buf;
else {
outbuf = malloc(crp->crp_payload_length,
M_AESNI, M_NOWAIT);
if (outbuf == NULL) {
error = ENOMEM;
goto out;
}
outallocated = true;
}
} else
outcopy = false;
} else {
outbuf = buf;
outcopy = allocated;
}
error = 0; error = 0;
encflag = CRYPTO_OP_IS_ENCRYPT(crp->crp_op); encflag = CRYPTO_OP_IS_ENCRYPT(crp->crp_op);
if (crp->crp_cipher_key != NULL) if (crp->crp_cipher_key != NULL)
aesni_cipher_setup_common(ses, csp, crp->crp_cipher_key, aesni_cipher_setup_common(ses, csp, crp->crp_cipher_key,
csp->csp_cipher_klen); csp->csp_cipher_klen);
crypto_read_iv(crp, iv); crypto_read_iv(crp, iv);
switch (csp->csp_cipher_alg) { switch (csp->csp_cipher_alg) {
case CRYPTO_AES_CBC: case CRYPTO_AES_CBC:
if (encflag) if (encflag)
aesni_encrypt_cbc(ses->rounds, ses->enc_schedule, aesni_encrypt_cbc(ses->rounds, ses->enc_schedule,
crp->crp_payload_length, buf, buf, iv); crp->crp_payload_length, buf, outbuf, iv);
else else {
if (buf != outbuf)
memcpy(outbuf, buf, crp->crp_payload_length);
aesni_decrypt_cbc(ses->rounds, ses->dec_schedule, aesni_decrypt_cbc(ses->rounds, ses->dec_schedule,
crp->crp_payload_length, buf, iv); crp->crp_payload_length, outbuf, iv);
}
break; break;
case CRYPTO_AES_ICM: case CRYPTO_AES_ICM:
/* encryption & decryption are the same */ /* encryption & decryption are the same */
aesni_encrypt_icm(ses->rounds, ses->enc_schedule, aesni_encrypt_icm(ses->rounds, ses->enc_schedule,
crp->crp_payload_length, buf, buf, iv); crp->crp_payload_length, buf, outbuf, iv);
break; break;
case CRYPTO_AES_XTS: case CRYPTO_AES_XTS:
if (encflag) if (encflag)
aesni_encrypt_xts(ses->rounds, ses->enc_schedule, aesni_encrypt_xts(ses->rounds, ses->enc_schedule,
ses->xts_schedule, crp->crp_payload_length, buf, ses->xts_schedule, crp->crp_payload_length, buf,
buf, iv); outbuf, iv);
else else
aesni_decrypt_xts(ses->rounds, ses->dec_schedule, aesni_decrypt_xts(ses->rounds, ses->dec_schedule,
ses->xts_schedule, crp->crp_payload_length, buf, ses->xts_schedule, crp->crp_payload_length, buf,
buf, iv); outbuf, iv);
break; break;
case CRYPTO_AES_NIST_GCM_16: case CRYPTO_AES_NIST_GCM_16:
if (encflag) { if (encflag) {
memset(tag, 0, sizeof(tag)); memset(tag, 0, sizeof(tag));
AES_GCM_encrypt(buf, buf, authbuf, iv, tag, AES_GCM_encrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds); csp->csp_ivlen, ses->enc_schedule, ses->rounds);
crypto_copyback(crp, crp->crp_digest_start, sizeof(tag), crypto_copyback(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
} else { } else {
crypto_copydata(crp, crp->crp_digest_start, sizeof(tag), crypto_copydata(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
if (!AES_GCM_decrypt(buf, buf, authbuf, iv, tag, if (!AES_GCM_decrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds)) csp->csp_ivlen, ses->enc_schedule, ses->rounds))
error = EBADMSG; error = EBADMSG;
} }
break; break;
case CRYPTO_AES_CCM_16: case CRYPTO_AES_CCM_16:
if (encflag) { if (encflag) {
memset(tag, 0, sizeof(tag)); memset(tag, 0, sizeof(tag));
AES_CCM_encrypt(buf, buf, authbuf, iv, tag, AES_CCM_encrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds); csp->csp_ivlen, ses->enc_schedule, ses->rounds);
crypto_copyback(crp, crp->crp_digest_start, sizeof(tag), crypto_copyback(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
} else { } else {
crypto_copydata(crp, crp->crp_digest_start, sizeof(tag), crypto_copydata(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
if (!AES_CCM_decrypt(buf, buf, authbuf, iv, tag, if (!AES_CCM_decrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds)) csp->csp_ivlen, ses->enc_schedule, ses->rounds))
error = EBADMSG; error = EBADMSG;
} }
break; break;
} }
if (allocated && error == 0) if (outcopy && error == 0)
crypto_copyback(crp, crp->crp_payload_start, crypto_copyback(crp, CRYPTO_HAS_OUTPUT_BUFFER(crp) ?
crp->crp_payload_length, buf); crp->crp_payload_output_start : crp->crp_payload_start,
crp->crp_payload_length, outbuf);
out: out:
if (allocated) { if (allocated) {
explicit_bzero(buf, crp->crp_payload_length); explicit_bzero(buf, crp->crp_payload_length);
free(buf, M_AESNI); free(buf, M_AESNI);
} }
if (authallocated) { if (authallocated) {
explicit_bzero(authbuf, crp->crp_aad_length); explicit_bzero(authbuf, crp->crp_aad_length);
free(authbuf, M_AESNI); free(authbuf, M_AESNI);
} }
if (outallocated) {
explicit_bzero(outbuf, crp->crp_payload_length);
free(outbuf, M_AESNI);
}
return (error); return (error);
} }
static int static int
aesni_cipher_mac(struct aesni_session *ses, struct cryptop *crp, aesni_cipher_mac(struct aesni_session *ses, struct cryptop *crp,
const struct crypto_session_params *csp) const struct crypto_session_params *csp)
{ {
union { union {
Show All 19 Lines for (i = 0; i < keylen; i++)
hmac_key[i] = key[i] ^ HMAC_IPAD_VAL; hmac_key[i] = key[i] ^ HMAC_IPAD_VAL;
for (i = keylen; i < sizeof(hmac_key); i++) for (i = keylen; i < sizeof(hmac_key); i++)
hmac_key[i] = 0 ^ HMAC_IPAD_VAL; hmac_key[i] = 0 ^ HMAC_IPAD_VAL;
ses->hash_update(&sctx, hmac_key, sizeof(hmac_key)); ses->hash_update(&sctx, hmac_key, sizeof(hmac_key));
crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length, crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int), ses->hash_update),
&sctx); &sctx);
if (CRYPTO_HAS_OUTPUT_BUFFER(crp) &&
CRYPTO_OP_IS_ENCRYPT(crp->crp_op))
crypto_apply_buf(&crp->crp_obuf,
crp->crp_payload_output_start,
crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int),
ses->hash_update), &sctx);
else
crypto_apply(crp, crp->crp_payload_start, crypto_apply(crp, crp->crp_payload_start,
crp->crp_payload_length, crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int),
&sctx); ses->hash_update), &sctx);
ses->hash_finalize(res, &sctx); ses->hash_finalize(res, &sctx);
/* Outer hash: (K ^ OPAD) || inner hash */ /* Outer hash: (K ^ OPAD) || inner hash */
ses->hash_init(&sctx); ses->hash_init(&sctx);
for (i = 0; i < keylen; i++) for (i = 0; i < keylen; i++)
hmac_key[i] = key[i] ^ HMAC_OPAD_VAL; hmac_key[i] = key[i] ^ HMAC_OPAD_VAL;
for (i = keylen; i < sizeof(hmac_key); i++) for (i = keylen; i < sizeof(hmac_key); i++)
hmac_key[i] = 0 ^ HMAC_OPAD_VAL; hmac_key[i] = 0 ^ HMAC_OPAD_VAL;
ses->hash_update(&sctx, hmac_key, sizeof(hmac_key)); ses->hash_update(&sctx, hmac_key, sizeof(hmac_key));
ses->hash_update(&sctx, res, ses->hash_len); ses->hash_update(&sctx, res, ses->hash_len);
ses->hash_finalize(res, &sctx); ses->hash_finalize(res, &sctx);
} else { } else {
ses->hash_init(&sctx); ses->hash_init(&sctx);
crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length, crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int), ses->hash_update),
&sctx); &sctx);
if (CRYPTO_HAS_OUTPUT_BUFFER(crp) &&
CRYPTO_OP_IS_ENCRYPT(crp->crp_op))
crypto_apply_buf(&crp->crp_obuf,
crp->crp_payload_output_start,
crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int),
ses->hash_update), &sctx);
else
crypto_apply(crp, crp->crp_payload_start, crypto_apply(crp, crp->crp_payload_start,
crp->crp_payload_length, crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int),
&sctx); ses->hash_update), &sctx);
ses->hash_finalize(res, &sctx); ses->hash_finalize(res, &sctx);
} }
if (crp->crp_op & CRYPTO_OP_VERIFY_DIGEST) { if (crp->crp_op & CRYPTO_OP_VERIFY_DIGEST) {
crypto_copydata(crp, crp->crp_digest_start, ses->mlen, res2); crypto_copydata(crp, crp->crp_digest_start, ses->mlen, res2);
if (timingsafe_bcmp(res, res2, ses->mlen) != 0) if (timingsafe_bcmp(res, res2, ses->mlen) != 0)
return (EBADMSG); return (EBADMSG);
} else } else
crypto_copyback(crp, crp->crp_digest_start, ses->mlen, res); crypto_copyback(crp, crp->crp_digest_start, ses->mlen, res);
return (0); return (0);
} }
View Options

sys/compat/linuxkpi/common/src/linuxkpi_videokmod.c

Show First 20 Lines • Show All 247 Lines • ▼ Show 20 Lines
} }
static int static int
aesni_probesession(device_t dev, const struct crypto_session_params *csp) aesni_probesession(device_t dev, const struct crypto_session_params *csp)
{ {
struct aesni_softc *sc; struct aesni_softc *sc;
sc = device_get_softc(dev); sc = device_get_softc(dev);
if (csp->csp_flags != 0) if ((csp->csp_flags & ~(CSP_F_SEPARATE_OUTPUT)) != 0)
return (EINVAL); return (EINVAL);
switch (csp->csp_mode) { switch (csp->csp_mode) {
case CSP_MODE_DIGEST: case CSP_MODE_DIGEST:
if (!aesni_auth_supported(sc, csp)) if (!aesni_auth_supported(sc, csp))
return (EINVAL); return (EINVAL);
break; break;
case CSP_MODE_CIPHER: case CSP_MODE_CIPHER:
if (!aesni_cipher_supported(sc, csp)) if (!aesni_cipher_supported(sc, csp))
▲ Show 20 Lines • Show All 407 Lines • ▼ Show 20 Linesaesni_cipher_process(struct aesni_session *ses, struct cryptop *crp)
} }
return (error); return (error);
} }
static int static int
aesni_cipher_crypt(struct aesni_session *ses, struct cryptop *crp, aesni_cipher_crypt(struct aesni_session *ses, struct cryptop *crp,
const struct crypto_session_params *csp) const struct crypto_session_params *csp)
{ {
uint8_t iv[AES_BLOCK_LEN], tag[GMAC_DIGEST_LEN], *buf, *authbuf; uint8_t iv[AES_BLOCK_LEN], tag[GMAC_DIGEST_LEN];
uint8_t *authbuf, *buf, *outbuf;
int error; int error;
bool encflag, allocated, authallocated; bool encflag, allocated, authallocated, outallocated, outcopy;
buf = aesni_cipher_alloc(crp, crp->crp_payload_start, buf = aesni_cipher_alloc(crp, crp->crp_payload_start,
crp->crp_payload_length, &allocated); crp->crp_payload_length, &allocated);
if (buf == NULL) if (buf == NULL)
return (ENOMEM); return (ENOMEM);
outallocated = false;
authallocated = false; authallocated = false;
authbuf = NULL; authbuf = NULL;
if (csp->csp_cipher_alg == CRYPTO_AES_NIST_GCM_16 || if (csp->csp_cipher_alg == CRYPTO_AES_NIST_GCM_16 ||
csp->csp_cipher_alg == CRYPTO_AES_CCM_16) { csp->csp_cipher_alg == CRYPTO_AES_CCM_16) {
authbuf = aesni_cipher_alloc(crp, crp->crp_aad_start, authbuf = aesni_cipher_alloc(crp, crp->crp_aad_start,
crp->crp_aad_length, &authallocated); crp->crp_aad_length, &authallocated);
if (authbuf == NULL) { if (authbuf == NULL) {
error = ENOMEM; error = ENOMEM;
goto out; goto out;
} }
} }
if (CRYPTO_HAS_OUTPUT_BUFFER(crp)) {
outbuf = crypto_buffer_contiguous_subsegment(&crp->crp_obuf,
crp->crp_payload_output_start, crp->crp_payload_length);
if (outbuf == NULL) {
outcopy = true;
if (allocated)
outbuf = buf;
else {
outbuf = malloc(crp->crp_payload_length,
M_AESNI, M_NOWAIT);
if (outbuf == NULL) {
error = ENOMEM;
goto out;
}
outallocated = true;
}
} else
outcopy = false;
} else {
outbuf = buf;
outcopy = allocated;
}
error = 0; error = 0;
encflag = CRYPTO_OP_IS_ENCRYPT(crp->crp_op); encflag = CRYPTO_OP_IS_ENCRYPT(crp->crp_op);
if (crp->crp_cipher_key != NULL) if (crp->crp_cipher_key != NULL)
aesni_cipher_setup_common(ses, csp, crp->crp_cipher_key, aesni_cipher_setup_common(ses, csp, crp->crp_cipher_key,
csp->csp_cipher_klen); csp->csp_cipher_klen);
crypto_read_iv(crp, iv); crypto_read_iv(crp, iv);
switch (csp->csp_cipher_alg) { switch (csp->csp_cipher_alg) {
case CRYPTO_AES_CBC: case CRYPTO_AES_CBC:
if (encflag) if (encflag)
aesni_encrypt_cbc(ses->rounds, ses->enc_schedule, aesni_encrypt_cbc(ses->rounds, ses->enc_schedule,
crp->crp_payload_length, buf, buf, iv); crp->crp_payload_length, buf, outbuf, iv);
else else {
if (buf != outbuf)
memcpy(outbuf, buf, crp->crp_payload_length);
aesni_decrypt_cbc(ses->rounds, ses->dec_schedule, aesni_decrypt_cbc(ses->rounds, ses->dec_schedule,
crp->crp_payload_length, buf, iv); crp->crp_payload_length, outbuf, iv);
}
break; break;
case CRYPTO_AES_ICM: case CRYPTO_AES_ICM:
/* encryption & decryption are the same */ /* encryption & decryption are the same */
aesni_encrypt_icm(ses->rounds, ses->enc_schedule, aesni_encrypt_icm(ses->rounds, ses->enc_schedule,
crp->crp_payload_length, buf, buf, iv); crp->crp_payload_length, buf, outbuf, iv);
break; break;
case CRYPTO_AES_XTS: case CRYPTO_AES_XTS:
if (encflag) if (encflag)
aesni_encrypt_xts(ses->rounds, ses->enc_schedule, aesni_encrypt_xts(ses->rounds, ses->enc_schedule,
ses->xts_schedule, crp->crp_payload_length, buf, ses->xts_schedule, crp->crp_payload_length, buf,
buf, iv); outbuf, iv);
else else
aesni_decrypt_xts(ses->rounds, ses->dec_schedule, aesni_decrypt_xts(ses->rounds, ses->dec_schedule,
ses->xts_schedule, crp->crp_payload_length, buf, ses->xts_schedule, crp->crp_payload_length, buf,
buf, iv); outbuf, iv);
break; break;
case CRYPTO_AES_NIST_GCM_16: case CRYPTO_AES_NIST_GCM_16:
if (encflag) { if (encflag) {
memset(tag, 0, sizeof(tag)); memset(tag, 0, sizeof(tag));
AES_GCM_encrypt(buf, buf, authbuf, iv, tag, AES_GCM_encrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds); csp->csp_ivlen, ses->enc_schedule, ses->rounds);
crypto_copyback(crp, crp->crp_digest_start, sizeof(tag), crypto_copyback(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
} else { } else {
crypto_copydata(crp, crp->crp_digest_start, sizeof(tag), crypto_copydata(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
if (!AES_GCM_decrypt(buf, buf, authbuf, iv, tag, if (!AES_GCM_decrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds)) csp->csp_ivlen, ses->enc_schedule, ses->rounds))
error = EBADMSG; error = EBADMSG;
} }
break; break;
case CRYPTO_AES_CCM_16: case CRYPTO_AES_CCM_16:
if (encflag) { if (encflag) {
memset(tag, 0, sizeof(tag)); memset(tag, 0, sizeof(tag));
AES_CCM_encrypt(buf, buf, authbuf, iv, tag, AES_CCM_encrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds); csp->csp_ivlen, ses->enc_schedule, ses->rounds);
crypto_copyback(crp, crp->crp_digest_start, sizeof(tag), crypto_copyback(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
} else { } else {
crypto_copydata(crp, crp->crp_digest_start, sizeof(tag), crypto_copydata(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
if (!AES_CCM_decrypt(buf, buf, authbuf, iv, tag, if (!AES_CCM_decrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds)) csp->csp_ivlen, ses->enc_schedule, ses->rounds))
error = EBADMSG; error = EBADMSG;
} }
break; break;
} }
if (allocated && error == 0) if (outcopy && error == 0)
crypto_copyback(crp, crp->crp_payload_start, crypto_copyback(crp, CRYPTO_HAS_OUTPUT_BUFFER(crp) ?
crp->crp_payload_length, buf); crp->crp_payload_output_start : crp->crp_payload_start,
crp->crp_payload_length, outbuf);
out: out:
if (allocated) { if (allocated) {
explicit_bzero(buf, crp->crp_payload_length); explicit_bzero(buf, crp->crp_payload_length);
free(buf, M_AESNI); free(buf, M_AESNI);
} }
if (authallocated) { if (authallocated) {
explicit_bzero(authbuf, crp->crp_aad_length); explicit_bzero(authbuf, crp->crp_aad_length);
free(authbuf, M_AESNI); free(authbuf, M_AESNI);
} }
if (outallocated) {
explicit_bzero(outbuf, crp->crp_payload_length);
free(outbuf, M_AESNI);
}
return (error); return (error);
} }
static int static int
aesni_cipher_mac(struct aesni_session *ses, struct cryptop *crp, aesni_cipher_mac(struct aesni_session *ses, struct cryptop *crp,
const struct crypto_session_params *csp) const struct crypto_session_params *csp)
{ {
union { union {
Show All 19 Lines for (i = 0; i < keylen; i++)
hmac_key[i] = key[i] ^ HMAC_IPAD_VAL; hmac_key[i] = key[i] ^ HMAC_IPAD_VAL;
for (i = keylen; i < sizeof(hmac_key); i++) for (i = keylen; i < sizeof(hmac_key); i++)
hmac_key[i] = 0 ^ HMAC_IPAD_VAL; hmac_key[i] = 0 ^ HMAC_IPAD_VAL;
ses->hash_update(&sctx, hmac_key, sizeof(hmac_key)); ses->hash_update(&sctx, hmac_key, sizeof(hmac_key));
crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length, crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int), ses->hash_update),
&sctx); &sctx);
if (CRYPTO_HAS_OUTPUT_BUFFER(crp) &&
CRYPTO_OP_IS_ENCRYPT(crp->crp_op))
crypto_apply_buf(&crp->crp_obuf,
crp->crp_payload_output_start,
crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int),
ses->hash_update), &sctx);
else
crypto_apply(crp, crp->crp_payload_start, crypto_apply(crp, crp->crp_payload_start,
crp->crp_payload_length, crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int),
&sctx); ses->hash_update), &sctx);
ses->hash_finalize(res, &sctx); ses->hash_finalize(res, &sctx);
/* Outer hash: (K ^ OPAD) || inner hash */ /* Outer hash: (K ^ OPAD) || inner hash */
ses->hash_init(&sctx); ses->hash_init(&sctx);
for (i = 0; i < keylen; i++) for (i = 0; i < keylen; i++)
hmac_key[i] = key[i] ^ HMAC_OPAD_VAL; hmac_key[i] = key[i] ^ HMAC_OPAD_VAL;
for (i = keylen; i < sizeof(hmac_key); i++) for (i = keylen; i < sizeof(hmac_key); i++)
hmac_key[i] = 0 ^ HMAC_OPAD_VAL; hmac_key[i] = 0 ^ HMAC_OPAD_VAL;
ses->hash_update(&sctx, hmac_key, sizeof(hmac_key)); ses->hash_update(&sctx, hmac_key, sizeof(hmac_key));
ses->hash_update(&sctx, res, ses->hash_len); ses->hash_update(&sctx, res, ses->hash_len);
ses->hash_finalize(res, &sctx); ses->hash_finalize(res, &sctx);
} else { } else {
ses->hash_init(&sctx); ses->hash_init(&sctx);
crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length, crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int), ses->hash_update),
&sctx); &sctx);
if (CRYPTO_HAS_OUTPUT_BUFFER(crp) &&
CRYPTO_OP_IS_ENCRYPT(crp->crp_op))
crypto_apply_buf(&crp->crp_obuf,
crp->crp_payload_output_start,
crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int),
ses->hash_update), &sctx);
else
crypto_apply(crp, crp->crp_payload_start, crypto_apply(crp, crp->crp_payload_start,
crp->crp_payload_length, crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int),
&sctx); ses->hash_update), &sctx);
ses->hash_finalize(res, &sctx); ses->hash_finalize(res, &sctx);
} }
if (crp->crp_op & CRYPTO_OP_VERIFY_DIGEST) { if (crp->crp_op & CRYPTO_OP_VERIFY_DIGEST) {
crypto_copydata(crp, crp->crp_digest_start, ses->mlen, res2); crypto_copydata(crp, crp->crp_digest_start, ses->mlen, res2);
if (timingsafe_bcmp(res, res2, ses->mlen) != 0) if (timingsafe_bcmp(res, res2, ses->mlen) != 0)
return (EBADMSG); return (EBADMSG);
} else } else
crypto_copyback(crp, crp->crp_digest_start, ses->mlen, res); crypto_copyback(crp, crp->crp_digest_start, ses->mlen, res);
return (0); return (0);
} }
View Options

sys/modules/Makefile

Show First 20 Lines • Show All 247 Lines • ▼ Show 20 Lines
} }
static int static int
aesni_probesession(device_t dev, const struct crypto_session_params *csp) aesni_probesession(device_t dev, const struct crypto_session_params *csp)
{ {
struct aesni_softc *sc; struct aesni_softc *sc;
sc = device_get_softc(dev); sc = device_get_softc(dev);
if (csp->csp_flags != 0) if ((csp->csp_flags & ~(CSP_F_SEPARATE_OUTPUT)) != 0)
return (EINVAL); return (EINVAL);
switch (csp->csp_mode) { switch (csp->csp_mode) {
case CSP_MODE_DIGEST: case CSP_MODE_DIGEST:
if (!aesni_auth_supported(sc, csp)) if (!aesni_auth_supported(sc, csp))
return (EINVAL); return (EINVAL);
break; break;
case CSP_MODE_CIPHER: case CSP_MODE_CIPHER:
if (!aesni_cipher_supported(sc, csp)) if (!aesni_cipher_supported(sc, csp))
▲ Show 20 Lines • Show All 407 Lines • ▼ Show 20 Linesaesni_cipher_process(struct aesni_session *ses, struct cryptop *crp)
} }
return (error); return (error);
} }
static int static int
aesni_cipher_crypt(struct aesni_session *ses, struct cryptop *crp, aesni_cipher_crypt(struct aesni_session *ses, struct cryptop *crp,
const struct crypto_session_params *csp) const struct crypto_session_params *csp)
{ {
uint8_t iv[AES_BLOCK_LEN], tag[GMAC_DIGEST_LEN], *buf, *authbuf; uint8_t iv[AES_BLOCK_LEN], tag[GMAC_DIGEST_LEN];
uint8_t *authbuf, *buf, *outbuf;
int error; int error;
bool encflag, allocated, authallocated; bool encflag, allocated, authallocated, outallocated, outcopy;
buf = aesni_cipher_alloc(crp, crp->crp_payload_start, buf = aesni_cipher_alloc(crp, crp->crp_payload_start,
crp->crp_payload_length, &allocated); crp->crp_payload_length, &allocated);
if (buf == NULL) if (buf == NULL)
return (ENOMEM); return (ENOMEM);
outallocated = false;
authallocated = false; authallocated = false;
authbuf = NULL; authbuf = NULL;
if (csp->csp_cipher_alg == CRYPTO_AES_NIST_GCM_16 || if (csp->csp_cipher_alg == CRYPTO_AES_NIST_GCM_16 ||
csp->csp_cipher_alg == CRYPTO_AES_CCM_16) { csp->csp_cipher_alg == CRYPTO_AES_CCM_16) {
authbuf = aesni_cipher_alloc(crp, crp->crp_aad_start, authbuf = aesni_cipher_alloc(crp, crp->crp_aad_start,
crp->crp_aad_length, &authallocated); crp->crp_aad_length, &authallocated);
if (authbuf == NULL) { if (authbuf == NULL) {
error = ENOMEM; error = ENOMEM;
goto out; goto out;
} }
} }
if (CRYPTO_HAS_OUTPUT_BUFFER(crp)) {
outbuf = crypto_buffer_contiguous_subsegment(&crp->crp_obuf,
crp->crp_payload_output_start, crp->crp_payload_length);
if (outbuf == NULL) {
outcopy = true;
if (allocated)
outbuf = buf;
else {
outbuf = malloc(crp->crp_payload_length,
M_AESNI, M_NOWAIT);
if (outbuf == NULL) {
error = ENOMEM;
goto out;
}
outallocated = true;
}
} else
outcopy = false;
} else {
outbuf = buf;
outcopy = allocated;
}
error = 0; error = 0;
encflag = CRYPTO_OP_IS_ENCRYPT(crp->crp_op); encflag = CRYPTO_OP_IS_ENCRYPT(crp->crp_op);
if (crp->crp_cipher_key != NULL) if (crp->crp_cipher_key != NULL)
aesni_cipher_setup_common(ses, csp, crp->crp_cipher_key, aesni_cipher_setup_common(ses, csp, crp->crp_cipher_key,
csp->csp_cipher_klen); csp->csp_cipher_klen);
crypto_read_iv(crp, iv); crypto_read_iv(crp, iv);
switch (csp->csp_cipher_alg) { switch (csp->csp_cipher_alg) {
case CRYPTO_AES_CBC: case CRYPTO_AES_CBC:
if (encflag) if (encflag)
aesni_encrypt_cbc(ses->rounds, ses->enc_schedule, aesni_encrypt_cbc(ses->rounds, ses->enc_schedule,
crp->crp_payload_length, buf, buf, iv); crp->crp_payload_length, buf, outbuf, iv);
else else {
if (buf != outbuf)
memcpy(outbuf, buf, crp->crp_payload_length);
aesni_decrypt_cbc(ses->rounds, ses->dec_schedule, aesni_decrypt_cbc(ses->rounds, ses->dec_schedule,
crp->crp_payload_length, buf, iv); crp->crp_payload_length, outbuf, iv);
}
break; break;
case CRYPTO_AES_ICM: case CRYPTO_AES_ICM:
/* encryption & decryption are the same */ /* encryption & decryption are the same */
aesni_encrypt_icm(ses->rounds, ses->enc_schedule, aesni_encrypt_icm(ses->rounds, ses->enc_schedule,
crp->crp_payload_length, buf, buf, iv); crp->crp_payload_length, buf, outbuf, iv);
break; break;
case CRYPTO_AES_XTS: case CRYPTO_AES_XTS:
if (encflag) if (encflag)
aesni_encrypt_xts(ses->rounds, ses->enc_schedule, aesni_encrypt_xts(ses->rounds, ses->enc_schedule,
ses->xts_schedule, crp->crp_payload_length, buf, ses->xts_schedule, crp->crp_payload_length, buf,
buf, iv); outbuf, iv);
else else
aesni_decrypt_xts(ses->rounds, ses->dec_schedule, aesni_decrypt_xts(ses->rounds, ses->dec_schedule,
ses->xts_schedule, crp->crp_payload_length, buf, ses->xts_schedule, crp->crp_payload_length, buf,
buf, iv); outbuf, iv);
break; break;
case CRYPTO_AES_NIST_GCM_16: case CRYPTO_AES_NIST_GCM_16:
if (encflag) { if (encflag) {
memset(tag, 0, sizeof(tag)); memset(tag, 0, sizeof(tag));
AES_GCM_encrypt(buf, buf, authbuf, iv, tag, AES_GCM_encrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds); csp->csp_ivlen, ses->enc_schedule, ses->rounds);
crypto_copyback(crp, crp->crp_digest_start, sizeof(tag), crypto_copyback(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
} else { } else {
crypto_copydata(crp, crp->crp_digest_start, sizeof(tag), crypto_copydata(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
if (!AES_GCM_decrypt(buf, buf, authbuf, iv, tag, if (!AES_GCM_decrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds)) csp->csp_ivlen, ses->enc_schedule, ses->rounds))
error = EBADMSG; error = EBADMSG;
} }
break; break;
case CRYPTO_AES_CCM_16: case CRYPTO_AES_CCM_16:
if (encflag) { if (encflag) {
memset(tag, 0, sizeof(tag)); memset(tag, 0, sizeof(tag));
AES_CCM_encrypt(buf, buf, authbuf, iv, tag, AES_CCM_encrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds); csp->csp_ivlen, ses->enc_schedule, ses->rounds);
crypto_copyback(crp, crp->crp_digest_start, sizeof(tag), crypto_copyback(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
} else { } else {
crypto_copydata(crp, crp->crp_digest_start, sizeof(tag), crypto_copydata(crp, crp->crp_digest_start, sizeof(tag),
tag); tag);
if (!AES_CCM_decrypt(buf, buf, authbuf, iv, tag, if (!AES_CCM_decrypt(buf, outbuf, authbuf, iv, tag,
crp->crp_payload_length, crp->crp_aad_length, crp->crp_payload_length, crp->crp_aad_length,
csp->csp_ivlen, ses->enc_schedule, ses->rounds)) csp->csp_ivlen, ses->enc_schedule, ses->rounds))
error = EBADMSG; error = EBADMSG;
} }
break; break;
} }
if (allocated && error == 0) if (outcopy && error == 0)
crypto_copyback(crp, crp->crp_payload_start, crypto_copyback(crp, CRYPTO_HAS_OUTPUT_BUFFER(crp) ?
crp->crp_payload_length, buf); crp->crp_payload_output_start : crp->crp_payload_start,
crp->crp_payload_length, outbuf);
out: out:
if (allocated) { if (allocated) {
explicit_bzero(buf, crp->crp_payload_length); explicit_bzero(buf, crp->crp_payload_length);
free(buf, M_AESNI); free(buf, M_AESNI);
} }
if (authallocated) { if (authallocated) {
explicit_bzero(authbuf, crp->crp_aad_length); explicit_bzero(authbuf, crp->crp_aad_length);
free(authbuf, M_AESNI); free(authbuf, M_AESNI);
} }
if (outallocated) {
explicit_bzero(outbuf, crp->crp_payload_length);
free(outbuf, M_AESNI);
}
return (error); return (error);
} }
static int static int
aesni_cipher_mac(struct aesni_session *ses, struct cryptop *crp, aesni_cipher_mac(struct aesni_session *ses, struct cryptop *crp,
const struct crypto_session_params *csp) const struct crypto_session_params *csp)
{ {
union { union {
Show All 19 Lines for (i = 0; i < keylen; i++)
hmac_key[i] = key[i] ^ HMAC_IPAD_VAL; hmac_key[i] = key[i] ^ HMAC_IPAD_VAL;
for (i = keylen; i < sizeof(hmac_key); i++) for (i = keylen; i < sizeof(hmac_key); i++)
hmac_key[i] = 0 ^ HMAC_IPAD_VAL; hmac_key[i] = 0 ^ HMAC_IPAD_VAL;
ses->hash_update(&sctx, hmac_key, sizeof(hmac_key)); ses->hash_update(&sctx, hmac_key, sizeof(hmac_key));
crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length, crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int), ses->hash_update),
&sctx); &sctx);
if (CRYPTO_HAS_OUTPUT_BUFFER(crp) &&
CRYPTO_OP_IS_ENCRYPT(crp->crp_op))
crypto_apply_buf(&crp->crp_obuf,
crp->crp_payload_output_start,
crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int),
ses->hash_update), &sctx);
else
crypto_apply(crp, crp->crp_payload_start, crypto_apply(crp, crp->crp_payload_start,
crp->crp_payload_length, crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int),
&sctx); ses->hash_update), &sctx);
ses->hash_finalize(res, &sctx); ses->hash_finalize(res, &sctx);
/* Outer hash: (K ^ OPAD) || inner hash */ /* Outer hash: (K ^ OPAD) || inner hash */
ses->hash_init(&sctx); ses->hash_init(&sctx);
for (i = 0; i < keylen; i++) for (i = 0; i < keylen; i++)
hmac_key[i] = key[i] ^ HMAC_OPAD_VAL; hmac_key[i] = key[i] ^ HMAC_OPAD_VAL;
for (i = keylen; i < sizeof(hmac_key); i++) for (i = keylen; i < sizeof(hmac_key); i++)
hmac_key[i] = 0 ^ HMAC_OPAD_VAL; hmac_key[i] = 0 ^ HMAC_OPAD_VAL;
ses->hash_update(&sctx, hmac_key, sizeof(hmac_key)); ses->hash_update(&sctx, hmac_key, sizeof(hmac_key));
ses->hash_update(&sctx, res, ses->hash_len); ses->hash_update(&sctx, res, ses->hash_len);
ses->hash_finalize(res, &sctx); ses->hash_finalize(res, &sctx);
} else { } else {
ses->hash_init(&sctx); ses->hash_init(&sctx);
crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length, crypto_apply(crp, crp->crp_aad_start, crp->crp_aad_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int), ses->hash_update),
&sctx); &sctx);
if (CRYPTO_HAS_OUTPUT_BUFFER(crp) &&
CRYPTO_OP_IS_ENCRYPT(crp->crp_op))
crypto_apply_buf(&crp->crp_obuf,
crp->crp_payload_output_start,
crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int),
ses->hash_update), &sctx);
else
crypto_apply(crp, crp->crp_payload_start, crypto_apply(crp, crp->crp_payload_start,
crp->crp_payload_length, crp->crp_payload_length,
__DECONST(int (*)(void *, void *, u_int), ses->hash_update), __DECONST(int (*)(void *, void *, u_int),
&sctx); ses->hash_update), &sctx);
ses->hash_finalize(res, &sctx); ses->hash_finalize(res, &sctx);
} }
if (crp->crp_op & CRYPTO_OP_VERIFY_DIGEST) { if (crp->crp_op & CRYPTO_OP_VERIFY_DIGEST) {
crypto_copydata(crp, crp->crp_digest_start, ses->mlen, res2); crypto_copydata(crp, crp->crp_digest_start, ses->mlen, res2);
if (timingsafe_bcmp(res, res2, ses->mlen) != 0) if (timingsafe_bcmp(res, res2, ses->mlen) != 0)
return (EBADMSG); return (EBADMSG);
} else } else
crypto_copyback(crp, crp->crp_digest_start, ses->mlen, res); crypto_copyback(crp, crp->crp_digest_start, ses->mlen, res);
return (0); return (0);
} }
View Options

sys/modules/linuxkpi_video/Makefile

Loading...