X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/b226f5e54a60dc81db17b1260381d7dbfea3cdf1..0a7de7458d150b5d4dffc935ba399be265ef0a1a:/bsd/netinet6/esp_core.c diff --git a/bsd/netinet6/esp_core.c b/bsd/netinet6/esp_core.c index 03fdcd7f1..c5448b8a5 100644 --- a/bsd/netinet6/esp_core.c +++ b/bsd/netinet6/esp_core.c @@ -107,91 +107,91 @@ #include #include -#define DBG_LAYER_BEG NETDBG_CODE(DBG_NETIPSEC, 1) -#define DBG_LAYER_END NETDBG_CODE(DBG_NETIPSEC, 3) -#define DBG_FNC_ESPAUTH NETDBG_CODE(DBG_NETIPSEC, (8 << 8)) +#define DBG_LAYER_BEG NETDBG_CODE(DBG_NETIPSEC, 1) +#define DBG_LAYER_END NETDBG_CODE(DBG_NETIPSEC, 3) +#define DBG_FNC_ESPAUTH NETDBG_CODE(DBG_NETIPSEC, (8 << 8)) #define MAX_SBUF_LEN 2000 extern lck_mtx_t *sadb_mutex; static int esp_null_mature(struct secasvar *); static int esp_null_decrypt(struct mbuf *, size_t, - struct secasvar *, const struct esp_algorithm *, int); + struct secasvar *, const struct esp_algorithm *, int); static int esp_null_encrypt(struct mbuf *, size_t, size_t, - struct secasvar *, const struct esp_algorithm *, int); + struct secasvar *, const struct esp_algorithm *, int); static int esp_descbc_mature(struct secasvar *); static int esp_descbc_ivlen(const struct esp_algorithm *, - struct secasvar *); + struct secasvar *); static int esp_des_schedule(const struct esp_algorithm *, - struct secasvar *); + struct secasvar *); static int esp_des_schedlen(const struct esp_algorithm *); static int esp_des_blockdecrypt(const struct esp_algorithm *, - struct secasvar *, u_int8_t *, u_int8_t *); + struct secasvar *, u_int8_t *, u_int8_t *); static int esp_des_blockencrypt(const struct esp_algorithm *, - struct secasvar *, u_int8_t *, u_int8_t *); + struct secasvar *, u_int8_t *, u_int8_t *); static int esp_cbc_mature(struct secasvar *); static int esp_3des_schedule(const struct esp_algorithm *, - struct secasvar *); + struct secasvar *); static int esp_3des_schedlen(const struct esp_algorithm *); static int esp_3des_blockdecrypt(const struct esp_algorithm *, - struct secasvar *, u_int8_t *, u_int8_t *); + struct secasvar *, u_int8_t *, u_int8_t *); static int esp_3des_blockencrypt(const struct esp_algorithm *, - struct secasvar *, u_int8_t *, u_int8_t *); + struct secasvar *, u_int8_t *, u_int8_t *); static int esp_common_ivlen(const struct esp_algorithm *, - struct secasvar *); + struct secasvar *); static int esp_cbc_decrypt(struct mbuf *, size_t, - struct secasvar *, const struct esp_algorithm *, int); + struct secasvar *, const struct esp_algorithm *, int); static int esp_cbc_encrypt(struct mbuf *, size_t, size_t, - struct secasvar *, const struct esp_algorithm *, int); + struct secasvar *, const struct esp_algorithm *, int); static int esp_gcm_mature(struct secasvar *); -#define MAXIVLEN 16 +#define MAXIVLEN 16 #define ESP_AESGCM_KEYLEN128 160 // 16-bytes key + 4 bytes salt #define ESP_AESGCM_KEYLEN192 224 // 24-bytes key + 4 bytes salt #define ESP_AESGCM_KEYLEN256 288 // 32-bytes key + 4 bytes salt static const struct esp_algorithm des_cbc = - { 8, -1, esp_descbc_mature, 64, 64, esp_des_schedlen, - "des-cbc", - esp_descbc_ivlen, esp_cbc_decrypt, - esp_cbc_encrypt, esp_des_schedule, - esp_des_blockdecrypt, esp_des_blockencrypt, - 0, 0, 0 }; +{ 8, -1, esp_descbc_mature, 64, 64, esp_des_schedlen, + "des-cbc", + esp_descbc_ivlen, esp_cbc_decrypt, + esp_cbc_encrypt, esp_des_schedule, + esp_des_blockdecrypt, esp_des_blockencrypt, + 0, 0, 0 }; static const struct esp_algorithm des3_cbc = - { 8, 8, esp_cbc_mature, 192, 192, esp_3des_schedlen, - "3des-cbc", - esp_common_ivlen, esp_cbc_decrypt, - esp_cbc_encrypt, esp_3des_schedule, - esp_3des_blockdecrypt, esp_3des_blockencrypt, - 0, 0, 0 }; +{ 8, 8, esp_cbc_mature, 192, 192, esp_3des_schedlen, + "3des-cbc", + esp_common_ivlen, esp_cbc_decrypt, + esp_cbc_encrypt, esp_3des_schedule, + esp_3des_blockdecrypt, esp_3des_blockencrypt, + 0, 0, 0 }; static const struct esp_algorithm null_esp = - { 1, 0, esp_null_mature, 0, 2048, 0, "null", - esp_common_ivlen, esp_null_decrypt, - esp_null_encrypt, NULL, NULL, NULL, - 0, 0, 0 }; +{ 1, 0, esp_null_mature, 0, 2048, 0, "null", + esp_common_ivlen, esp_null_decrypt, + esp_null_encrypt, NULL, NULL, NULL, + 0, 0, 0 }; static const struct esp_algorithm aes_cbc = - { 16, 16, esp_cbc_mature, 128, 256, esp_aes_schedlen, - "aes-cbc", - esp_common_ivlen, esp_cbc_decrypt_aes, - esp_cbc_encrypt_aes, esp_aes_schedule, - 0, 0, - 0, 0, 0 }; +{ 16, 16, esp_cbc_mature, 128, 256, esp_aes_schedlen, + "aes-cbc", + esp_common_ivlen, esp_cbc_decrypt_aes, + esp_cbc_encrypt_aes, esp_aes_schedule, + 0, 0, + 0, 0, 0 }; static const struct esp_algorithm aes_gcm = - { 4, 8, esp_gcm_mature, ESP_AESGCM_KEYLEN128, ESP_AESGCM_KEYLEN256, esp_gcm_schedlen, - "aes-gcm", - esp_common_ivlen, esp_gcm_decrypt_aes, - esp_gcm_encrypt_aes, esp_gcm_schedule, - 0, 0, - 16, esp_gcm_decrypt_finalize, esp_gcm_encrypt_finalize}; +{ 4, 8, esp_gcm_mature, ESP_AESGCM_KEYLEN128, ESP_AESGCM_KEYLEN256, esp_gcm_schedlen, + "aes-gcm", + esp_common_ivlen, esp_gcm_decrypt_aes, + esp_gcm_encrypt_aes, esp_gcm_schedule, + 0, 0, + 16, esp_gcm_decrypt_finalize, esp_gcm_encrypt_finalize}; static const struct esp_algorithm chacha_poly = - { ESP_CHACHAPOLY_PAD_BOUND, ESP_CHACHAPOLY_IV_LEN, - esp_chachapoly_mature, ESP_CHACHAPOLY_KEYBITS_WITH_SALT, - ESP_CHACHAPOLY_KEYBITS_WITH_SALT, esp_chachapoly_schedlen, - "chacha-poly", esp_chachapoly_ivlen, esp_chachapoly_decrypt, - esp_chachapoly_encrypt, esp_chachapoly_schedule, - NULL, NULL, ESP_CHACHAPOLY_ICV_LEN, - esp_chachapoly_decrypt_finalize, esp_chachapoly_encrypt_finalize}; +{ ESP_CHACHAPOLY_PAD_BOUND, ESP_CHACHAPOLY_IV_LEN, + esp_chachapoly_mature, ESP_CHACHAPOLY_KEYBITS_WITH_SALT, + ESP_CHACHAPOLY_KEYBITS_WITH_SALT, esp_chachapoly_schedlen, + "chacha-poly", esp_chachapoly_ivlen, esp_chachapoly_decrypt, + esp_chachapoly_encrypt, esp_chachapoly_schedule, + NULL, NULL, ESP_CHACHAPOLY_ICV_LEN, + esp_chachapoly_decrypt_finalize, esp_chachapoly_encrypt_finalize}; static const struct esp_algorithm *esp_algorithms[] = { &des_cbc, @@ -230,10 +230,11 @@ esp_max_ivlen(void) int ivlen; ivlen = 0; - for (idx = 0; idx < sizeof(esp_algorithms)/sizeof(esp_algorithms[0]); - idx++) { - if (esp_algorithms[idx]->ivlenval > ivlen) + for (idx = 0; idx < sizeof(esp_algorithms) / sizeof(esp_algorithms[0]); + idx++) { + if (esp_algorithms[idx]->ivlenval > ivlen) { ivlen = esp_algorithms[idx]->ivlenval; + } } return ivlen; @@ -263,11 +264,11 @@ esp_schedule(const struct esp_algorithm *algo, struct secasvar *sav) /* prevent disallowed implicit IV */ if (((sav->flags & SADB_X_EXT_IIV) != 0) && - (sav->alg_enc != SADB_X_EALG_AES_GCM) && - (sav->alg_enc != SADB_X_EALG_CHACHA20POLY1305)) { + (sav->alg_enc != SADB_X_EALG_AES_GCM) && + (sav->alg_enc != SADB_X_EALG_CHACHA20POLY1305)) { ipseclog((LOG_ERR, "esp_schedule %s: implicit IV not allowed\n", - algo->name)); + algo->name)); lck_mtx_unlock(sadb_mutex); return EINVAL; } @@ -277,7 +278,7 @@ esp_schedule(const struct esp_algorithm *algo, struct secasvar *sav) lck_mtx_unlock(sadb_mutex); return 0; } - + sav->schedlen = (*algo->schedlen)(algo); if ((signed) sav->schedlen < 0) { lck_mtx_unlock(sadb_mutex); @@ -309,7 +310,6 @@ static int esp_null_mature( __unused struct secasvar *sav) { - /* anything is okay */ return 0; } @@ -317,25 +317,23 @@ esp_null_mature( static int esp_null_decrypt( __unused struct mbuf *m, - __unused size_t off, /* offset to ESP header */ + __unused size_t off, /* offset to ESP header */ __unused struct secasvar *sav, __unused const struct esp_algorithm *algo, __unused int ivlen) { - return 0; /* do nothing */ } static int esp_null_encrypt( __unused struct mbuf *m, - __unused size_t off, /* offset to ESP header */ - __unused size_t plen, /* payload length (to be encrypted) */ + __unused size_t off, /* offset to ESP header */ + __unused size_t plen, /* payload length (to be encrypted) */ __unused struct secasvar *sav, __unused const struct esp_algorithm *algo, __unused int ivlen) { - return 0; /* do nothing */ } @@ -385,13 +383,15 @@ esp_descbc_ivlen( __unused const struct esp_algorithm *algo, struct secasvar *sav) { - - if (!sav) + if (!sav) { return 8; - if ((sav->flags & SADB_X_EXT_OLD) && (sav->flags & SADB_X_EXT_IV4B)) + } + if ((sav->flags & SADB_X_EXT_OLD) && (sav->flags & SADB_X_EXT_IV4B)) { return 4; - if (!(sav->flags & SADB_X_EXT_OLD) && (sav->flags & SADB_X_EXT_DERIV)) + } + if (!(sav->flags & SADB_X_EXT_OLD) && (sav->flags & SADB_X_EXT_DERIV)) { return 4; + } return 8; } @@ -407,13 +407,13 @@ esp_des_schedule( __unused const struct esp_algorithm *algo, struct secasvar *sav) { - LCK_MTX_ASSERT(sadb_mutex, LCK_MTX_ASSERT_OWNED); if (des_ecb_key_sched((des_cblock *)_KEYBUF(sav->key_enc), - (des_ecb_key_schedule *)sav->sched)) + (des_ecb_key_schedule *)sav->sched)) { return EINVAL; - else + } else { return 0; + } } static int @@ -559,7 +559,7 @@ esp_gcm_mature(struct secasvar *sav) break; default: ipseclog((LOG_ERR, - "esp_gcm_mature %s: invalid algo %d.\n", sav->alg_enc)); + "esp_gcm_mature %s: invalid algo %d.\n", sav->alg_enc)); return 1; } @@ -570,7 +570,6 @@ static int esp_3des_schedlen( __unused const struct esp_algorithm *algo) { - return sizeof(des3_ecb_key_schedule); } @@ -582,10 +581,11 @@ esp_3des_schedule( LCK_MTX_ASSERT(sadb_mutex, LCK_MTX_ASSERT_OWNED); if (des3_ecb_key_sched((des_cblock *)_KEYBUF(sav->key_enc), - (des3_ecb_key_schedule *)sav->sched)) + (des3_ecb_key_schedule *)sav->sched)) { return EINVAL; - else + } else { return 0; + } } static int @@ -598,7 +598,7 @@ esp_3des_blockdecrypt( /* assumption: d has a good alignment */ bcopy(s, d, sizeof(DES_LONG) * 2); des3_ecb_encrypt((des_cblock *)d, (des_cblock *)d, - (des3_ecb_key_schedule *)sav->sched, DES_DECRYPT); + (des3_ecb_key_schedule *)sav->sched, DES_DECRYPT); return 0; } @@ -612,7 +612,7 @@ esp_3des_blockencrypt( /* assumption: d has a good alignment */ bcopy(s, d, sizeof(DES_LONG) * 2); des3_ecb_encrypt((des_cblock *)d, (des_cblock *)d, - (des3_ecb_key_schedule *)sav->sched, DES_ENCRYPT); + (des3_ecb_key_schedule *)sav->sched, DES_ENCRYPT); return 0; } @@ -621,20 +621,20 @@ esp_common_ivlen( const struct esp_algorithm *algo, __unused struct secasvar *sav) { - - if (!algo) + if (!algo) { panic("esp_common_ivlen: unknown algorithm"); + } return algo->ivlenval; } static int esp_cbc_decrypt(struct mbuf *m, size_t off, struct secasvar *sav, - const struct esp_algorithm *algo, int ivlen) + const struct esp_algorithm *algo, int ivlen) { struct mbuf *s; struct mbuf *d, *d0, *dp; - int soff, doff; /* offset from the head of chain, to head of this mbuf */ - int sn, dn; /* offset from the head of the mbuf, to meat */ + int soff, doff; /* offset from the head of chain, to head of this mbuf */ + int sn, dn; /* offset from the head of the mbuf, to meat */ size_t ivoff, bodyoff; u_int8_t iv[MAXIVLEN] __attribute__((aligned(4))), *ivp; u_int8_t *sbuf = NULL, *sp, *sp_unaligned; @@ -691,9 +691,9 @@ esp_cbc_decrypt(struct mbuf *m, size_t off, struct secasvar *sav, m_copydata(m, ivoff, ivlen, (caddr_t) iv); /* extend iv */ - if (ivlen == blocklen) + if (ivlen == blocklen) { ; - else if (ivlen == 4 && blocklen == 8) { + } else if (ivlen == 4 && blocklen == 8) { bcopy(&iv[0], &iv[4], 4); iv[4] ^= 0xff; iv[5] ^= 0xff; @@ -740,13 +740,15 @@ esp_cbc_decrypt(struct mbuf *m, size_t off, struct secasvar *sav, scutoff = sn; /* skip over empty mbuf */ - while (s && s->m_len == 0) + while (s && s->m_len == 0) { s = s->m_next; + } // Allocate blocksized buffer for unaligned or non-contiguous access sbuf = (u_int8_t *)_MALLOC(blocklen, M_SECA, M_DONTWAIT); - if (sbuf == NULL) + if (sbuf == NULL) { return ENOBUFS; + } while (soff < m->m_pkthdr.len) { /* source */ if (sn + blocklen <= s->m_len) { @@ -760,8 +762,9 @@ esp_cbc_decrypt(struct mbuf *m, size_t off, struct secasvar *sav, /* destination */ if (!d || dn + blocklen > d->m_len) { - if (d) + if (d) { dp = d; + } MGET(d, M_DONTWAIT, MT_DATA); i = m->m_pkthdr.len - (soff + sn); if (d && i > MLEN) { @@ -773,15 +776,18 @@ esp_cbc_decrypt(struct mbuf *m, size_t off, struct secasvar *sav, } if (!d) { m_freem(m); - if (d0) + if (d0) { m_freem(d0); + } result = ENOBUFS; goto end; } - if (!d0) + if (!d0) { d0 = d; - if (dp) + } + if (dp) { dp->m_next = d; + } // try to make mbuf data aligned if (!IPSEC_IS_P2ALIGNED(d->m_data)) { @@ -790,8 +796,9 @@ esp_cbc_decrypt(struct mbuf *m, size_t off, struct secasvar *sav, d->m_len = 0; d->m_len = (M_TRAILINGSPACE(d) / blocklen) * blocklen; - if (d->m_len > i) + if (d->m_len > i) { d->m_len = i; + } dn = 0; } @@ -815,15 +822,17 @@ esp_cbc_decrypt(struct mbuf *m, size_t off, struct secasvar *sav, /* xor */ p = ivp ? ivp : iv; q = mtod(d, u_int8_t *) + dn; - for (i = 0; i < blocklen; i++) + for (i = 0; i < blocklen; i++) { q[i] ^= p[i]; + } /* next iv */ if (sp == sbuf) { bcopy(sbuf, iv, blocklen); ivp = NULL; - } else + } else { ivp = sp; + } sn += blocklen; dn += blocklen; @@ -844,8 +853,9 @@ esp_cbc_decrypt(struct mbuf *m, size_t off, struct secasvar *sav, bzero(iv, sizeof(iv)); bzero(sbuf, blocklen); end: - if (sbuf != NULL) + if (sbuf != NULL) { FREE(sbuf, M_SECA); + } return result; } @@ -860,8 +870,8 @@ esp_cbc_encrypt( { struct mbuf *s; struct mbuf *d, *d0, *dp; - int soff, doff; /* offset from the head of chain, to head of this mbuf */ - int sn, dn; /* offset from the head of the mbuf, to meat */ + int soff, doff; /* offset from the head of chain, to head of this mbuf */ + int sn, dn; /* offset from the head of the mbuf, to meat */ size_t ivoff, bodyoff; u_int8_t iv[MAXIVLEN] __attribute__((aligned(4))), *ivp; u_int8_t *sbuf = NULL, *sp, *sp_unaligned; @@ -915,18 +925,18 @@ esp_cbc_encrypt( } /* put iv into the packet. if we are in derived mode, use seqno. */ - if (derived) + if (derived) { m_copydata(m, ivoff, ivlen, (caddr_t) iv); - else { + } else { bcopy(sav->iv, iv, ivlen); /* maybe it is better to overwrite dest, not source */ m_copyback(m, ivoff, ivlen, (caddr_t) iv); } /* extend iv */ - if (ivlen == blocklen) + if (ivlen == blocklen) { ; - else if (ivlen == 4 && blocklen == 8) { + } else if (ivlen == 4 && blocklen == 8) { bcopy(&iv[0], &iv[4], 4); iv[4] ^= 0xff; iv[5] ^= 0xff; @@ -973,13 +983,15 @@ esp_cbc_encrypt( scutoff = sn; /* skip over empty mbuf */ - while (s && s->m_len == 0) + while (s && s->m_len == 0) { s = s->m_next; + } // Allocate blocksized buffer for unaligned or non-contiguous access - sbuf = (u_int8_t *)_MALLOC(blocklen, M_SECA, M_DONTWAIT); - if (sbuf == NULL) - return ENOBUFS; + sbuf = (u_int8_t *)_MALLOC(blocklen, M_SECA, M_DONTWAIT); + if (sbuf == NULL) { + return ENOBUFS; + } while (soff < m->m_pkthdr.len) { /* source */ if (sn + blocklen <= s->m_len) { @@ -993,8 +1005,9 @@ esp_cbc_encrypt( /* destination */ if (!d || dn + blocklen > d->m_len) { - if (d) + if (d) { dp = d; + } MGET(d, M_DONTWAIT, MT_DATA); i = m->m_pkthdr.len - (soff + sn); if (d && i > MLEN) { @@ -1006,15 +1019,18 @@ esp_cbc_encrypt( } if (!d) { m_freem(m); - if (d0) + if (d0) { m_freem(d0); + } result = ENOBUFS; goto end; } - if (!d0) + if (!d0) { d0 = d; - if (dp) + } + if (dp) { dp->m_next = d; + } // try to make mbuf data aligned if (!IPSEC_IS_P2ALIGNED(d->m_data)) { @@ -1023,16 +1039,18 @@ esp_cbc_encrypt( d->m_len = 0; d->m_len = (M_TRAILINGSPACE(d) / blocklen) * blocklen; - if (d->m_len > i) + if (d->m_len > i) { d->m_len = i; + } dn = 0; } /* xor */ p = ivp ? ivp : iv; q = sp; - for (i = 0; i < blocklen; i++) + for (i = 0; i < blocklen; i++) { q[i] ^= p[i]; + } /* encrypt */ // check input pointer alignment and use a separate aligned buffer (if sp is not aligned on 4-byte boundary). @@ -1075,8 +1093,9 @@ esp_cbc_encrypt( key_sa_stir_iv(sav); end: - if (sbuf != NULL) + if (sbuf != NULL) { FREE(sbuf, M_SECA); + } return result; } @@ -1086,8 +1105,8 @@ end: int esp_auth( struct mbuf *m0, - size_t skip, /* offset to ESP header */ - size_t length, /* payload length */ + size_t skip, /* offset to ESP header */ + size_t length, /* payload length */ struct secasvar *sav, u_char *sum) { @@ -1110,19 +1129,19 @@ esp_auth( return EINVAL; } - KERNEL_DEBUG(DBG_FNC_ESPAUTH | DBG_FUNC_START, skip,length,0,0,0); + KERNEL_DEBUG(DBG_FNC_ESPAUTH | DBG_FUNC_START, skip, length, 0, 0, 0); /* * length of esp part (excluding authentication data) must be 4n, * since nexthdr must be at offset 4n+3. */ if (length % 4) { ipseclog((LOG_ERR, "esp_auth: length is not multiple of 4\n")); - KERNEL_DEBUG(DBG_FNC_ESPAUTH | DBG_FUNC_END, 1,0,0,0,0); + KERNEL_DEBUG(DBG_FNC_ESPAUTH | DBG_FUNC_END, 1, 0, 0, 0, 0); return EINVAL; } if (!sav) { ipseclog((LOG_DEBUG, "esp_auth: NULL SA passed\n")); - KERNEL_DEBUG(DBG_FNC_ESPAUTH | DBG_FUNC_END, 2,0,0,0,0); + KERNEL_DEBUG(DBG_FNC_ESPAUTH | DBG_FUNC_END, 2, 0, 0, 0, 0); return EINVAL; } algo = ah_algorithm_lookup(sav->alg_auth); @@ -1130,7 +1149,7 @@ esp_auth( ipseclog((LOG_ERR, "esp_auth: bad ESP auth algorithm passed: %d\n", sav->alg_auth)); - KERNEL_DEBUG(DBG_FNC_ESPAUTH | DBG_FUNC_END, 3,0,0,0,0); + KERNEL_DEBUG(DBG_FNC_ESPAUTH | DBG_FUNC_END, 3, 0, 0, 0, 0); return EINVAL; } @@ -1142,14 +1161,15 @@ esp_auth( ipseclog((LOG_DEBUG, "esp_auth: AH_MAXSUMSIZE is too small: siz=%lu\n", (u_int32_t)siz)); - KERNEL_DEBUG(DBG_FNC_ESPAUTH | DBG_FUNC_END, 4,0,0,0,0); + KERNEL_DEBUG(DBG_FNC_ESPAUTH | DBG_FUNC_END, 4, 0, 0, 0, 0); return EINVAL; } /* skip the header */ while (skip) { - if (!m) + if (!m) { panic("mbuf chain?"); + } if (m->m_len <= skip) { skip -= m->m_len; m = m->m_next; @@ -1162,16 +1182,17 @@ esp_auth( error = (*algo->init)(&s, sav); if (error) { - KERNEL_DEBUG(DBG_FNC_ESPAUTH | DBG_FUNC_END, 5,0,0,0,0); + KERNEL_DEBUG(DBG_FNC_ESPAUTH | DBG_FUNC_END, 5, 0, 0, 0, 0); return error; } while (0 < length) { - if (!m) + if (!m) { panic("mbuf chain?"); + } if (m->m_len - off < length) { (*algo->update)(&s, (caddr_t)(mtod(m, u_char *) + off), - m->m_len - off); + m->m_len - off); length -= m->m_len - off; m = m->m_next; off = 0; @@ -1181,7 +1202,7 @@ esp_auth( } } (*algo->result)(&s, (caddr_t) sumbuf, sizeof(sumbuf)); - bcopy(sumbuf, sum, siz); /*XXX*/ - KERNEL_DEBUG(DBG_FNC_ESPAUTH | DBG_FUNC_END, 6,0,0,0,0); + bcopy(sumbuf, sum, siz); /*XXX*/ + KERNEL_DEBUG(DBG_FNC_ESPAUTH | DBG_FUNC_END, 6, 0, 0, 0, 0); return 0; }