#ifdef KERNEL
#ifndef UKERNEL
#include "afs/stds.h"
+#if defined(AFS_AIX_ENV) || defined(AFS_AUX_ENV) || defined(AFS_SUN5_ENV)
+#include "h/systm.h"
+#endif
#include "h/types.h"
#if !defined(AFS_LINUX20_ENV) && !defined(AFS_OBSD_ENV)
#include "netinet/in.h"
#include "sboxes.h"
#include "fcrypt.h"
#include "rxkad.h"
-
+#include <des/stats.h>
#ifdef TCRYPT
int ROUNDS = 16;
kword[1] = (kword[1] >> 11) | (temp << (56 - 32 - 11));
schedule[i] = kword[0];
}
- LOCK_RXKAD_STATS rxkad_stats.fc_key_scheds++;
- UNLOCK_RXKAD_STATS return 0;
+ INC_RXKAD_STATS(fc_key_scheds);
+ return 0;
}
/* IN int encrypt; * 0 ==> decrypt, else encrypt */
afs_int32
-fc_ecb_encrypt(afs_uint32 * clear, afs_uint32 * cipher,
+fc_ecb_encrypt(void * clear, void * cipher,
fc_KeySchedule schedule, int encrypt)
{
afs_uint32 L, R;
- afs_uint32 S, P;
- unsigned char *Pchar = (unsigned char *)&P;
- unsigned char *Schar = (unsigned char *)&S;
+ volatile afs_uint32 S, P;
+ volatile unsigned char *Pchar = (unsigned char *)&P;
+ volatile unsigned char *Schar = (unsigned char *)&S;
int i;
#if defined(vax) || (defined(mips) && defined(MIPSEL)) || defined(AFSLITTLE_ENDIAN)
memcpy(&L, clear, sizeof(afs_int32));
memcpy(&R, clear + 1, sizeof(afs_int32));
#else
- L = ntohl(*clear);
- R = ntohl(*(clear + 1));
+ L = ntohl(*((afs_uint32 *)clear));
+ R = ntohl(*((afs_uint32 *)clear + 1));
#endif
if (encrypt) {
- LOCK_RXKAD_STATS rxkad_stats.fc_encrypts[ENCRYPT]++;
- UNLOCK_RXKAD_STATS for (i = 0; i < (ROUNDS / 2); i++) {
+ INC_RXKAD_STATS(fc_encrypts[ENCRYPT]);
+ for (i = 0; i < (ROUNDS / 2); i++) {
S = *schedule++ ^ R; /* xor R with key bits from schedule */
Pchar[Byte2] = sbox0[Schar[Byte0]]; /* do 8-bit S Box subst. */
Pchar[Byte3] = sbox1[Schar[Byte1]]; /* and permute the result */
R ^= P;
}
} else {
- LOCK_RXKAD_STATS rxkad_stats.fc_encrypts[DECRYPT]++;
- UNLOCK_RXKAD_STATS schedule = &schedule[ROUNDS - 1]; /* start at end of key schedule */
+ INC_RXKAD_STATS(fc_encrypts[DECRYPT]);
+ schedule = &schedule[ROUNDS - 1]; /* start at end of key schedule */
for (i = 0; i < (ROUNDS / 2); i++) {
S = *schedule-- ^ L; /* xor R with key bits from schedule */
Pchar[Byte2] = sbox0[Schar[Byte0]]; /* do 8-bit S Box subst. and */
memcpy(cipher, &L, sizeof(afs_int32));
memcpy(cipher + 1, &R, sizeof(afs_int32));
#else
- *cipher = htonl(L);
- *(cipher + 1) = htonl(R);
+ *((afs_int32 *)cipher) = htonl(L);
+ *((afs_int32 *)cipher + 1) = htonl(R);
#endif
return 0;
}
afs_uint32 *xor; * 8 bytes of initialization vector *
*/
afs_int32
-fc_cbc_encrypt(char *input, char *output, afs_int32 length,
+fc_cbc_encrypt(void *input, void *output, afs_int32 length,
fc_KeySchedule key, afs_uint32 * xor, int encrypt)
{
afs_uint32 i, j;
for (i = 0; length > 0; i++, length -= 8) {
/* get input */
memcpy(t_input, input, sizeof(t_input));
- input += sizeof(t_input);
+ input=((char *)input) + sizeof(t_input);
/* zero pad */
for (j = length; j <= 7; j++)
/* copy temp output and save it for cbc */
memcpy(output, t_output, sizeof(t_output));
- output += sizeof(t_output);
+ output=(char *)output + sizeof(t_output);
/* calculate xor value for next round from plain & cipher text */
xor[0] = t_input[0] ^ t_output[0];
for (i = 0; length > 0; i++, length -= 8) {
/* get input */
memcpy(t_input, input, sizeof(t_input));
- input += sizeof(t_input);
+ input=((char *)input) + sizeof(t_input);
/* no padding for decrypt */
fc_ecb_encrypt(t_input, t_output, key, encrypt);
/* copy temp output */
memcpy(output, t_output, sizeof(t_output));
- output += sizeof(t_output);
+ output=((char *)output) + sizeof(t_output);
/* calculate xor value for next round from plain & cipher text */
xor[0] = t_input[0] ^ t_output[0];