OM_uint32 _gssapi_unwrap_arcfour(OM_uint32 *minor_status,
const gsskrb5_ctx context_handle,
krb5_context context,
const gss_buffer_t input_message_buffer,
gss_buffer_t output_message_buffer,
int *conf_state,
gss_qop_t *qop_state,
krb5_keyblock *key)
{
u_char Klocaldata[16];
krb5_keyblock Klocal;
krb5_error_code ret;
uint32_t seq_number;
size_t datalen;
OM_uint32 omret;
u_char k6_data[16], SND_SEQ[8], Confounder[8];
u_char cksum_data[8];
u_char *p, *p0;
int cmp;
int conf_flag;
size_t padlen = 0, len;
if (conf_state)
*conf_state = 0;
if (qop_state)
*qop_state = 0;
p0 = input_message_buffer->value;
if (IS_DCE_STYLE(context_handle)) {
len = GSS_ARCFOUR_WRAP_TOKEN_SIZE +
GSS_ARCFOUR_WRAP_TOKEN_DCE_DER_HEADER_SIZE;
if (input_message_buffer->length < len)
return GSS_S_BAD_MECH;
} else {
len = input_message_buffer->length;
}
omret = _gssapi_verify_mech_header(&p0,
len,
GSS_KRB5_MECHANISM);
if (omret)
return omret;
/* length of mech header */
len = (p0 - (u_char *)input_message_buffer->value) +
GSS_ARCFOUR_WRAP_TOKEN_SIZE;
if (len > input_message_buffer->length)
return GSS_S_BAD_MECH;
/* length of data */
datalen = input_message_buffer->length - len;
p = p0;
if (memcmp(p, "\x02\x01", 2) != 0)
return GSS_S_BAD_SIG;
p += 2;
if (memcmp(p, "\x11\x00", 2) != 0) /* SGN_ALG = HMAC MD5 ARCFOUR */
return GSS_S_BAD_SIG;
p += 2;
if (memcmp (p, "\x10\x00", 2) == 0)
conf_flag = 1;
else if (memcmp (p, "\xff\xff", 2) == 0)
conf_flag = 0;
else
return GSS_S_BAD_SIG;
p += 2;
if (memcmp (p, "\xff\xff", 2) != 0)
return GSS_S_BAD_MIC;
p = NULL;
ret = arcfour_mic_key(context, key,
p0 + 16, 8, /* SGN_CKSUM */
k6_data, sizeof(k6_data));
if (ret) {
*minor_status = ret;
return GSS_S_FAILURE;
}
{
RC4_KEY rc4_key;
RC4_set_key (&rc4_key, sizeof(k6_data), k6_data);
RC4 (&rc4_key, 8, p0 + 8, SND_SEQ); /* SND_SEQ */
memset(&rc4_key, 0, sizeof(rc4_key));
memset(k6_data, 0, sizeof(k6_data));
}
_gsskrb5_decode_be_om_uint32(SND_SEQ, &seq_number);
if (context_handle->more_flags & LOCAL)
cmp = memcmp(&SND_SEQ[4], "\xff\xff\xff\xff", 4);
else
cmp = memcmp(&SND_SEQ[4], "\x00\x00\x00\x00", 4);
if (cmp != 0) {
*minor_status = 0;
return GSS_S_BAD_MIC;
}
{
int i;
Klocal.keytype = key->keytype;
Klocal.keyvalue.data = Klocaldata;
Klocal.keyvalue.length = sizeof(Klocaldata);
for (i = 0; i < 16; i++)
Klocaldata[i] = ((u_char *)key->keyvalue.data)[i] ^ 0xF0;
}
ret = arcfour_mic_key(context, &Klocal,
SND_SEQ, 4,
k6_data, sizeof(k6_data));
memset(Klocaldata, 0, sizeof(Klocaldata));
if (ret) {
*minor_status = ret;
return GSS_S_FAILURE;
}
output_message_buffer->value = malloc(datalen);
if (output_message_buffer->value == NULL) {
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
output_message_buffer->length = datalen;
if(conf_flag) {
RC4_KEY rc4_key;
RC4_set_key (&rc4_key, sizeof(k6_data), k6_data);
RC4 (&rc4_key, 8, p0 + 24, Confounder); /* Confounder */
RC4 (&rc4_key, datalen, p0 + GSS_ARCFOUR_WRAP_TOKEN_SIZE,
output_message_buffer->value);
memset(&rc4_key, 0, sizeof(rc4_key));
} else {
memcpy(Confounder, p0 + 24, 8); /* Confounder */
memcpy(output_message_buffer->value,
p0 + GSS_ARCFOUR_WRAP_TOKEN_SIZE,
datalen);
}
memset(k6_data, 0, sizeof(k6_data));
if (!IS_DCE_STYLE(context_handle)) {
ret = _gssapi_verify_pad(output_message_buffer, datalen, &padlen);
if (ret) {
_gsskrb5_release_buffer(minor_status, output_message_buffer);
*minor_status = 0;
return ret;
}
output_message_buffer->length -= padlen;
}
ret = arcfour_mic_cksum(context,
key, KRB5_KU_USAGE_SEAL,
cksum_data, sizeof(cksum_data),
p0, 8,
Confounder, sizeof(Confounder),
output_message_buffer->value,
output_message_buffer->length + padlen);
if (ret) {
_gsskrb5_release_buffer(minor_status, output_message_buffer);
*minor_status = ret;
return GSS_S_FAILURE;
}
cmp = memcmp(cksum_data, p0 + 16, 8); /* SGN_CKSUM */
if (cmp) {
_gsskrb5_release_buffer(minor_status, output_message_buffer);
*minor_status = 0;
return GSS_S_BAD_MIC;
}
HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);
omret = _gssapi_msg_order_check(context_handle->order, seq_number);
HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
if (omret)
return omret;
if (conf_state)
*conf_state = conf_flag;
*minor_status = 0;
return GSS_S_COMPLETE;
}
OM_uint32
_gssapi_verify_mic_arcfour(OM_uint32 * minor_status,
const gsskrb5_ctx context_handle,
krb5_context context,
const gss_buffer_t message_buffer,
const gss_buffer_t token_buffer,
gss_qop_t * qop_state,
krb5_keyblock *key,
char *type)
{
krb5_error_code ret;
uint32_t seq_number;
OM_uint32 omret;
u_char SND_SEQ[8], cksum_data[8], *p;
char k6_data[16];
int cmp;
if (qop_state)
*qop_state = 0;
p = token_buffer->value;
omret = _gsskrb5_verify_header (&p,
token_buffer->length,
(u_char *)type,
GSS_KRB5_MECHANISM);
if (omret)
return omret;
if (memcmp(p, "\x11\x00", 2) != 0) /* SGN_ALG = HMAC MD5 ARCFOUR */
return GSS_S_BAD_SIG;
p += 2;
if (memcmp (p, "\xff\xff\xff\xff", 4) != 0)
return GSS_S_BAD_MIC;
p += 4;
ret = arcfour_mic_cksum(context,
key, KRB5_KU_USAGE_SIGN,
cksum_data, sizeof(cksum_data),
p - 8, 8,
message_buffer->value, message_buffer->length,
NULL, 0);
if (ret) {
*minor_status = ret;
return GSS_S_FAILURE;
}
ret = arcfour_mic_key(context, key,
cksum_data, sizeof(cksum_data),
k6_data, sizeof(k6_data));
if (ret) {
*minor_status = ret;
return GSS_S_FAILURE;
}
cmp = memcmp(cksum_data, p + 8, 8);
if (cmp) {
*minor_status = 0;
return GSS_S_BAD_MIC;
}
{
RC4_KEY rc4_key;
RC4_set_key (&rc4_key, sizeof(k6_data), (void*)k6_data);
RC4 (&rc4_key, 8, p, SND_SEQ);
memset(&rc4_key, 0, sizeof(rc4_key));
memset(k6_data, 0, sizeof(k6_data));
}
_gsskrb5_decode_be_om_uint32(SND_SEQ, &seq_number);
if (context_handle->more_flags & LOCAL)
cmp = memcmp(&SND_SEQ[4], "\xff\xff\xff\xff", 4);
else
cmp = memcmp(&SND_SEQ[4], "\x00\x00\x00\x00", 4);
memset(SND_SEQ, 0, sizeof(SND_SEQ));
if (cmp != 0) {
*minor_status = 0;
return GSS_S_BAD_MIC;
}
HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);
omret = _gssapi_msg_order_check(context_handle->order, seq_number);
HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
if (omret)
return omret;
*minor_status = 0;
return GSS_S_COMPLETE;
}
OM_uint32
_gssapi_wrap_arcfour(OM_uint32 * minor_status,
const gsskrb5_ctx context_handle,
krb5_context context,
int conf_req_flag,
gss_qop_t qop_req,
const gss_buffer_t input_message_buffer,
int * conf_state,
gss_buffer_t output_message_buffer,
krb5_keyblock *key)
{
u_char Klocaldata[16], k6_data[16], *p, *p0;
size_t len, total_len, datalen;
krb5_keyblock Klocal;
krb5_error_code ret;
int32_t seq_number;
if (conf_state)
*conf_state = 0;
datalen = input_message_buffer->length;
if (IS_DCE_STYLE(context_handle)) {
len = GSS_ARCFOUR_WRAP_TOKEN_SIZE;
_gssapi_encap_length(len, &len, &total_len, GSS_KRB5_MECHANISM);
total_len += datalen;
} else {
datalen += 1; /* padding */
len = datalen + GSS_ARCFOUR_WRAP_TOKEN_SIZE;
_gssapi_encap_length(len, &len, &total_len, GSS_KRB5_MECHANISM);
}
output_message_buffer->length = total_len;
output_message_buffer->value = malloc (total_len);
if (output_message_buffer->value == NULL) {
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
p0 = _gssapi_make_mech_header(output_message_buffer->value,
len,
GSS_KRB5_MECHANISM);
p = p0;
*p++ = 0x02; /* TOK_ID */
*p++ = 0x01;
*p++ = 0x11; /* SGN_ALG */
*p++ = 0x00;
if (conf_req_flag) {
*p++ = 0x10; /* SEAL_ALG */
*p++ = 0x00;
} else {
*p++ = 0xff; /* SEAL_ALG */
*p++ = 0xff;
}
*p++ = 0xff; /* Filler */
*p++ = 0xff;
p = NULL;
HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);
krb5_auth_con_getlocalseqnumber (context,
context_handle->auth_context,
&seq_number);
_gsskrb5_encode_be_om_uint32(seq_number, p0 + 8);
krb5_auth_con_setlocalseqnumber (context,
context_handle->auth_context,
++seq_number);
HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
memset (p0 + 8 + 4,
(context_handle->more_flags & LOCAL) ? 0 : 0xff,
4);
krb5_generate_random_block(p0 + 24, 8); /* fill in Confounder */
/* p points to data */
p = p0 + GSS_ARCFOUR_WRAP_TOKEN_SIZE;
memcpy(p, input_message_buffer->value, input_message_buffer->length);
if (!IS_DCE_STYLE(context_handle))
p[input_message_buffer->length] = 1; /* padding */
ret = arcfour_mic_cksum(context,
key, KRB5_KU_USAGE_SEAL,
p0 + 16, 8, /* SGN_CKSUM */
p0, 8, /* TOK_ID, SGN_ALG, SEAL_ALG, Filler */
p0 + 24, 8, /* Confounder */
p0 + GSS_ARCFOUR_WRAP_TOKEN_SIZE,
datalen);
if (ret) {
*minor_status = ret;
_gsskrb5_release_buffer(minor_status, output_message_buffer);
return GSS_S_FAILURE;
}
{
int i;
Klocal.keytype = key->keytype;
Klocal.keyvalue.data = Klocaldata;
Klocal.keyvalue.length = sizeof(Klocaldata);
for (i = 0; i < 16; i++)
Klocaldata[i] = ((u_char *)key->keyvalue.data)[i] ^ 0xF0;
}
ret = arcfour_mic_key(context, &Klocal,
p0 + 8, 4, /* SND_SEQ */
k6_data, sizeof(k6_data));
memset(Klocaldata, 0, sizeof(Klocaldata));
if (ret) {
_gsskrb5_release_buffer(minor_status, output_message_buffer);
*minor_status = ret;
return GSS_S_FAILURE;
}
if(conf_req_flag) {
RC4_KEY rc4_key;
RC4_set_key (&rc4_key, sizeof(k6_data), (void *)k6_data);
/* XXX ? */
RC4 (&rc4_key, 8 + datalen, p0 + 24, p0 + 24); /* Confounder + data */
memset(&rc4_key, 0, sizeof(rc4_key));
}
memset(k6_data, 0, sizeof(k6_data));
ret = arcfour_mic_key(context, key,
p0 + 16, 8, /* SGN_CKSUM */
k6_data, sizeof(k6_data));
if (ret) {
_gsskrb5_release_buffer(minor_status, output_message_buffer);
*minor_status = ret;
return GSS_S_FAILURE;
}
{
RC4_KEY rc4_key;
RC4_set_key (&rc4_key, sizeof(k6_data), k6_data);
RC4 (&rc4_key, 8, p0 + 8, p0 + 8); /* SND_SEQ */
memset(&rc4_key, 0, sizeof(rc4_key));
memset(k6_data, 0, sizeof(k6_data));
}
if (conf_state)
*conf_state = conf_req_flag;
*minor_status = 0;
return GSS_S_COMPLETE;
}
int main(int argc, char *argv[])
{
int i,err=0;
int j;
unsigned char *p;
RC4_KEY key;
unsigned char buf[512],obuf[512];
for (i=0; i<512; i++) buf[i]=0x01;
for (i=0; i<6; i++)
{
RC4_set_key(&key,keys[i][0],&(keys[i][1]));
memset(obuf,0x00,sizeof(obuf));
RC4(&key,data_len[i],&(data[i][0]),obuf);
if (memcmp(obuf,output[i],data_len[i]+1) != 0)
{
printf("error calculating RC4\n");
printf("output:");
for (j=0; j<data_len[i]+1; j++)
printf(" %02x",obuf[j]);
printf("\n");
printf("expect:");
p= &(output[i][0]);
for (j=0; j<data_len[i]+1; j++)
printf(" %02x",*(p++));
printf("\n");
err++;
}
else
printf("test %d ok\n",i);
}
printf("test end processing ");
for (i=0; i<data_len[3]; i++)
{
RC4_set_key(&key,keys[3][0],&(keys[3][1]));
memset(obuf,0x00,sizeof(obuf));
RC4(&key,i,&(data[3][0]),obuf);
if ((memcmp(obuf,output[3],i) != 0) || (obuf[i] != 0))
{
printf("error in RC4 length processing\n");
printf("output:");
for (j=0; j<i+1; j++)
printf(" %02x",obuf[j]);
printf("\n");
printf("expect:");
p= &(output[3][0]);
for (j=0; j<i; j++)
printf(" %02x",*(p++));
printf(" 00\n");
err++;
}
else
{
printf(".");
fflush(stdout);
}
}
printf("done\n");
printf("test multi-call ");
for (i=0; i<data_len[3]; i++)
{
RC4_set_key(&key,keys[3][0],&(keys[3][1]));
memset(obuf,0x00,sizeof(obuf));
RC4(&key,i,&(data[3][0]),obuf);
RC4(&key,data_len[3]-i,&(data[3][i]),&(obuf[i]));
if (memcmp(obuf,output[3],data_len[3]+1) != 0)
{
printf("error in RC4 multi-call processing\n");
printf("output:");
for (j=0; j<data_len[3]+1; j++)
printf(" %02x",obuf[j]);
printf("\n");
printf("expect:");
p= &(output[3][0]);
for (j=0; j<data_len[3]+1; j++)
printf(" %02x",*(p++));
err++;
}
else
{
printf(".");
fflush(stdout);
}
}
printf("done\n");
EXIT(err);
return(0);
}
OM_uint32
_gssapi_get_mic_arcfour(OM_uint32 * minor_status,
const gsskrb5_ctx context_handle,
krb5_context context,
gss_qop_t qop_req,
const gss_buffer_t message_buffer,
gss_buffer_t message_token,
krb5_keyblock *key)
{
krb5_error_code ret;
int32_t seq_number;
size_t len, total_len;
u_char k6_data[16], *p0, *p;
RC4_KEY rc4_key;
_gsskrb5_encap_length (22, &len, &total_len, GSS_KRB5_MECHANISM);
message_token->length = total_len;
message_token->value = malloc (total_len);
if (message_token->value == NULL) {
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
p0 = _gssapi_make_mech_header(message_token->value,
len,
GSS_KRB5_MECHANISM);
p = p0;
*p++ = 0x01; /* TOK_ID */
*p++ = 0x01;
*p++ = 0x11; /* SGN_ALG */
*p++ = 0x00;
*p++ = 0xff; /* Filler */
*p++ = 0xff;
*p++ = 0xff;
*p++ = 0xff;
p = NULL;
ret = arcfour_mic_cksum(context,
key, KRB5_KU_USAGE_SIGN,
p0 + 16, 8, /* SGN_CKSUM */
p0, 8, /* TOK_ID, SGN_ALG, Filer */
message_buffer->value, message_buffer->length,
NULL, 0);
if (ret) {
_gsskrb5_release_buffer(minor_status, message_token);
*minor_status = ret;
return GSS_S_FAILURE;
}
ret = arcfour_mic_key(context, key,
p0 + 16, 8, /* SGN_CKSUM */
k6_data, sizeof(k6_data));
if (ret) {
_gsskrb5_release_buffer(minor_status, message_token);
*minor_status = ret;
return GSS_S_FAILURE;
}
HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);
krb5_auth_con_getlocalseqnumber (context,
context_handle->auth_context,
&seq_number);
p = p0 + 8; /* SND_SEQ */
_gsskrb5_encode_be_om_uint32(seq_number, p);
krb5_auth_con_setlocalseqnumber (context,
context_handle->auth_context,
++seq_number);
HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
memset (p + 4, (context_handle->more_flags & LOCAL) ? 0 : 0xff, 4);
RC4_set_key (&rc4_key, sizeof(k6_data), k6_data);
RC4 (&rc4_key, 8, p, p);
memset(&rc4_key, 0, sizeof(rc4_key));
memset(k6_data, 0, sizeof(k6_data));
*minor_status = 0;
return GSS_S_COMPLETE;
}
static int rc4_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
const unsigned char *in, unsigned int inl)
{
RC4(&data(ctx)->ks,inl,in,out);
return 1;
}
void crypto_rc4(CryptoRc4 rc4, uint32 length, const uint8* in_data, uint8* out_data)
{
RC4(&rc4->rc4_key, length, in_data, out_data);
}
BOOL CALLBACK DlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
OPENFILENAME ofn;
POINT pt;
RECT rect;
switch(uMsg){
case WM_INITDIALOG:
InitCommonControls();
hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_MAIN));
SendMessage(hDlg, WM_SETICON, (WPARAM)ICON_SMALL, (LPARAM)hIcon);
CheckDlgButton(hDlg, IDC_BACKUP, BST_CHECKED);
SendMessage(GetDlgItem(hDlg, IDC_FILE), EM_SETREADONLY, (WPARAM)TRUE, (LPARAM)0);
hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_EXE));
SendMessage(GetDlgItem(hDlg, IDC_ICONIMG), STM_SETICON, (WPARAM)hIcon, (LPARAM)0);
EnableWindow(GetDlgItem(hDlg, IDC_BUILD), FALSE);
SetWindowPos(hDlg, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
break;
case WM_CLOSE:
EndDialog(hDlg, 0);
break;
case WM_PAINT:
SendMessage(GetDlgItem(hDlg, IDC_ICONIMG), STM_SETICON, (WPARAM)hIcon, (LPARAM)0);
break;
case WM_DROPFILES:
HDROP hDrop;
hDrop = HDROP(wParam);
DragQueryFile(hDrop, 0, szEFileName, sizeof(szEFileName));
DragFinish(hDrop);
if(LoadPE(szEFileName) == FALSE)
{
MessageBox(hDlg, "Could not load file!", "Cryptic", MB_ICONERROR);
return TRUE;
}
SetDlgItemText(hDlg, IDC_FILE, szEFileName);
EnableWindow(GetDlgItem(hDlg, IDC_BUILD), TRUE);
break;
case WM_MOUSEMOVE:
GetCursorPos(&pt);
GetWindowRect(GetDlgItem(hDlg, IDC_ICONIMG), &rect);
if(PtInRect(&rect, pt))
{
SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(32649)));
}
else
{
SetCursor(LoadCursor(NULL, IDC_ARROW));
}
break;
case WM_LBUTTONDOWN:
GetCursorPos(&pt);
GetWindowRect(GetDlgItem(hDlg, IDC_ICONIMG), &rect);
if(PtInRect(&rect, pt))
{
SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(32649)));
memset(&ofn, 0, sizeof(ofn));
szIFileName[0] = '\0';
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = hDlg;
ofn.lpstrFilter = "Icon Files (*.ico)\0*.ico\0\0";
ofn.lpstrFile = szIFileName;
ofn.nMaxFile = MAX_PATH;
ofn.Flags = OFN_PATHMUSTEXIST;
if(GetOpenFileName(&ofn))
{
hIcon = ExtractIcon(hInst, szIFileName, 0);
SendMessage(GetDlgItem(hDlg, IDC_ICONIMG), STM_SETICON, (WPARAM)hIcon, (LPARAM)0);
}
}
break;
case WM_RBUTTONDOWN:
GetCursorPos(&pt);
GetWindowRect(GetDlgItem(hDlg, IDC_ICONIMG), &rect);
if(PtInRect(&rect, pt))
{
SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(32649)));
}
break;
case WM_COMMAND:
switch LOWORD(wParam){
case IDC_BROWSE:
memset(&ofn, 0, sizeof(ofn));
szEFileName[0] = '\0';
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = hDlg;
ofn.lpstrFilter = "Executable Files (*.exe)\0*.exe\0\0";
ofn.lpstrFile = szEFileName;
ofn.nMaxFile = MAX_PATH;
ofn.Flags = OFN_PATHMUSTEXIST;
if(GetOpenFileName(&ofn))
{
if(LoadPE(szEFileName) == FALSE)
{
MessageBox(hDlg, "Could not load file!", "Cryptic", MB_ICONERROR);
return TRUE;
}
SetDlgItemText(hDlg, IDC_FILE, szEFileName);
EnableWindow(GetDlgItem(hDlg, IDC_BUILD), TRUE);
}
break;
case IDC_BUILD:
EnableControls(hDlg, FALSE);
HRSRC hRsrc;
hRsrc = FindResource(NULL, MAKEINTRESOURCE(IDR_STUB), "STUB");
if(hRsrc == NULL)
{
MessageBox(hDlg, "Could not find resource!", "Cryptic", MB_ICONERROR);
EnableControls(hDlg, TRUE);
return TRUE;
}
DWORD dwRsrcSize;
dwRsrcSize = SizeofResource(NULL, hRsrc);
HGLOBAL hGlob;
hGlob = LoadResource(NULL, hRsrc);
if(hGlob == NULL)
{
MessageBox(hDlg, "Could not load resource!", "Cryptic", MB_ICONERROR);
EnableControls(hDlg, TRUE);
return TRUE;
}
LPBYTE lpBuffer;
lpBuffer = (LPBYTE)LockResource(hGlob);
if(lpBuffer == NULL)
{
MessageBox(hDlg, "Could not lock resource!", "Cryptic", MB_ICONERROR);
EnableControls(hDlg, TRUE);
return TRUE;
}
GetDlgItemText(hDlg, IDC_FILE, szEFileName, MAX_PATH);
if(IsDlgButtonChecked(hDlg, IDC_BACKUP) == BST_CHECKED)
{
CHAR szBFileName[MAX_PATH];
GetDlgItemText(hDlg, IDC_FILE, szBFileName, MAX_PATH);
strcat(szBFileName, ".bak");
if(CopyFile(szEFileName, szBFileName, FALSE) == 0)
{
free(lpBuffer);
MessageBox(hDlg, "Could not copy file!", "Cryptic", MB_ICONERROR);
EnableControls(hDlg, TRUE);
return TRUE;
}
}
BYTE lpKey[14];
srand(time(NULL));
int i;
for(i = 0; i < 15; i++)
{
lpKey[i] = BYTE(rand() % 255 + 1);
}
HANDLE hFile;
hFile = CreateFile(szEFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
if(hFile == INVALID_HANDLE_VALUE)
{
free(lpBuffer);
MessageBox(hDlg, "Could not create file!", "Cryptic", MB_ICONERROR);
EnableControls(hDlg, TRUE);
return TRUE;
}
DWORD dwBytesWritten;
if(WriteFile(hFile, lpBuffer, dwRsrcSize, &dwBytesWritten, NULL) == 0)
{
CloseHandle(hFile);
free(lpBuffer);
MessageBox(hDlg, "Could not write to file!", "Cryptic", MB_ICONERROR);
EnableControls(hDlg, TRUE);
return TRUE;
}
CloseHandle(hFile);
free(lpBuffer);
if(IsDlgButtonChecked(hDlg, IDC_ADDICON) == BST_CHECKED)
{
if(AddIcon(szIFileName, szEFileName) == FALSE)
{
MessageBox(hDlg, "Could add icon!", "Cryptic", MB_ICONERROR);
EnableControls(hDlg, TRUE);
return TRUE;
}
}
HANDLE hUpdate;
hUpdate = BeginUpdateResource(szEFileName, FALSE);
if(hUpdate == NULL)
{
MessageBox(hDlg, "Could add resource!", "Cryptic", MB_ICONERROR);
EnableControls(hDlg, TRUE);
return TRUE;
}
if(UpdateResource(hUpdate, RT_RCDATA, MAKEINTRESOURCE(150), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), RC4(lpFileBuffer, lpKey, dwFileSize, 15), dwFileSize) == FALSE)
{
MessageBox(hDlg, "Could add resource!", "Cryptic", MB_ICONERROR);
EnableControls(hDlg, TRUE);
return TRUE;
}
if(UpdateResource(hUpdate, RT_RCDATA, MAKEINTRESOURCE(151), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), &lpKey[0], 15) == FALSE)
{
MessageBox(hDlg, "Could add resource!", "Cryptic", MB_ICONERROR);
EnableControls(hDlg, TRUE);
return TRUE;
}
if(EndUpdateResource(hUpdate, FALSE) == FALSE)
{
MessageBox(hDlg, "Could add resource!", "Cryptic", MB_ICONERROR);
EnableControls(hDlg, TRUE);
return TRUE;
}
RC4(lpFileBuffer, lpKey, dwFileSize, 15);
pish = (PIMAGE_SECTION_HEADER)&lpFileBuffer[pidh->e_lfanew + sizeof(IMAGE_NT_HEADERS) + sizeof(IMAGE_SECTION_HEADER) * (pinh->FileHeader.NumberOfSections - 1)];
if(dwFileSize > (pish->PointerToRawData + pish->SizeOfRawData))
{
MessageBox(hDlg, "EOF data found!", "Cryptic", MB_OK);
hFile = CreateFile(szEFileName, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
if(hFile == INVALID_HANDLE_VALUE)
{
MessageBox(hDlg, "Could not open file!", "Cryptic", MB_ICONERROR);
EnableControls(hDlg, TRUE);
return TRUE;
}
SetFilePointer(hFile, 0, NULL, FILE_END);
if(WriteFile(hFile, &lpFileBuffer[pish->PointerToRawData + pish->SizeOfRawData + 1], dwFileSize - (pish->PointerToRawData + pish->SizeOfRawData), &dwBytesWritten, NULL) == 0)
{
CloseHandle(hFile);
MessageBox(hDlg, "Could not write to file!", "Cryptic", MB_ICONERROR);
EnableControls(hDlg, TRUE);
return TRUE;
}
CloseHandle(hFile);
}
MessageBox(hDlg, "File successfully crypted!", "Cryptic", MB_ICONINFORMATION);
EnableControls(hDlg, TRUE);
break;
case IDC_ABOUT:
MessageBox(hDlg, "Cryptic v3.0\nCoded by Tughack", "About", MB_ICONINFORMATION);
break;
case IDC_EXIT:
EndDialog(hDlg, 0);
break;
}
}
return FALSE;
}
int main(int argc, char *argv[])
{
TINYCLR_SSL_FILE *in=NULL,*out=NULL;
char *infile=NULL,*outfile=NULL,*keystr=NULL;
RC4_KEY key;
char buf[BUFSIZ];
int badops=0,i;
char **pp;
unsigned char md[MD5_DIGEST_LENGTH];
argc--;
argv++;
while (argc >= 1)
{
if (TINYCLR_SSL_STRCMP(*argv,"-in") == 0)
{
if (--argc < 1) goto bad;
infile= *(++argv);
}
else if (TINYCLR_SSL_STRCMP(*argv,"-out") == 0)
{
if (--argc < 1) goto bad;
outfile= *(++argv);
}
else if (TINYCLR_SSL_STRCMP(*argv,"-key") == 0)
{
if (--argc < 1) goto bad;
keystr= *(++argv);
}
else
{
TINYCLR_SSL_FPRINTF(OPENSSL_TYPE__FILE_STDERR,"unknown option %s\n",*argv);
badops=1;
break;
}
argc--;
argv++;
}
if (badops)
{
bad:
for (pp=usage; (*pp != NULL); pp++)
TINYCLR_SSL_FPRINTF(OPENSSL_TYPE__FILE_STDERR,"%s",*pp);
TINYCLR_SSL_EXIT(1);
}
if (infile == NULL)
in=OPENSSL_TYPE__FILE_STDIN;
else
{
in=TINYCLR_SSL_FOPEN(infile,"r");
if (in == NULL)
{
TINYCLR_SSL_PERROR("open");
TINYCLR_SSL_EXIT(1);
}
}
if (outfile == NULL)
out=OPENSSL_TYPE__FILE_STDOUT;
else
{
out=TINYCLR_SSL_FOPEN(outfile,"w");
if (out == NULL)
{
TINYCLR_SSL_PERROR("open");
TINYCLR_SSL_EXIT(1);
}
}
#ifdef OPENSSL_SYS_MSDOS
/* This should set the file to binary mode. */
{
#include <fcntl.h>
setmode(fileno(in),O_BINARY);
setmode(fileno(out),O_BINARY);
}
#endif
if (keystr == NULL)
{ /* get key */
i=EVP_read_pw_string(buf,BUFSIZ,"Enter RC4 password:"******"bad password read\n");
TINYCLR_SSL_EXIT(1);
}
keystr=buf;
}
EVP_Digest((unsigned char *)keystr,TINYCLR_SSL_STRLEN(keystr),md,NULL,EVP_md5(),NULL);
OPENSSL_cleanse(keystr,TINYCLR_SSL_STRLEN(keystr));
RC4_set_key(&key,MD5_DIGEST_LENGTH,md);
for(;;)
{
i=TINYCLR_SSL_FREAD(buf,1,BUFSIZ,in);
if (i == 0) break;
if (i < 0)
{
TINYCLR_SSL_PERROR("read");
TINYCLR_SSL_EXIT(1);
}
RC4(&key,(unsigned int)i,(unsigned char *)buf,
(unsigned char *)buf);
i=TINYCLR_SSL_FWRITE(buf,(unsigned int)i,1,out);
if (i != 1)
{
TINYCLR_SSL_PERROR("write");
TINYCLR_SSL_EXIT(1);
}
}
TINYCLR_SSL_FCLOSE(out);
TINYCLR_SSL_FCLOSE(in);
TINYCLR_SSL_EXIT(0);
return(1);
}
//--------------------------------------------------
// lib1x_authxmitsm_key_transmit:
// This function has the initialization for entry to state Key_Transmit for the
// Authenticator Key Transmit State Machine.
//--------------------------------------------------
void lib1x_kxsm_key_transmit( Auth_Pae * auth_pae, Global_Params * global, Auth_KeyxmitSM * key_sm )
{
struct lib1x_ethernet * eth;
struct lib1x_eapol * eapol;
struct lib1x_eapolkey_dot1x *eapol_key;
OCTET_STRING ocCounter;
u_long ulKeyLen = 5;
RC4_KEY rc4key;
//TODO read default key with ioctl
/*
u_char szDefaultKey[16] = {0x11, 0x11,0x11, 0x11,0x11, 0x11,0x11, 0x11,
0x11, 0x11,0x11, 0x11,0x11, 0x11,0x11, 0x11};
*/
u_char szIV[16] = {0x22, 0x22,0x22, 0x22,0x22, 0x22,0x22, 0x22,
0x22, 0x22,0x22, 0x22,0x22, 0x22,0x22, 0x22};
u_char szKeyBuf[64];
// Set the from / to ethernet addresses.
memset(auth_pae->sendBuffer, 0, 100);
eth = ( struct lib1x_ethernet * ) auth_pae->sendBuffer;
memcpy ( eth->ether_dhost, auth_pae->supp_addr, ETHER_HDRLEN);
memcpy ( eth->ether_shost, auth_pae->global->TxRx->oursupp_addr, ETHER_HDRLEN);
eth->ether_type = htons( LIB1X_ETHER_EAPOL_TYPE );
eapol = ( struct lib1x_eapol * )( auth_pae->sendBuffer + ETHER_HDRLEN );
eapol->protocol_version = LIB1X_EAPOL_VER;
eapol->packet_type = LIB1X_EAPOL_KEY;
if(global->RSNVariable.UnicastCipher == DOT11_ENC_WEP40)
ulKeyLen = 5;
else if(global->RSNVariable.UnicastCipher == DOT11_ENC_WEP104)
ulKeyLen = 13;
//
else if(global->RSNVariable.UnicastCipher == DOT11_ENC_NONE)
ulKeyLen = 13;
//
if(auth_pae->sendreplyready == TRUE)
{
//----------------------------------------
//(1)Send Group Key using default key
//----------------------------------------
eapol_key = (struct lib1x_eapolkey_dot1x *) ( ( (u_char *) eapol) + LIB1X_EAPOL_HDRLEN );
eapol_key->type = LIB1X_KEY_TYPE_RC4;
lib1x_S2N(ulKeyLen, (u_char*)&eapol_key->length);
ocCounter.Octet = (u_char*)malloc(LIB1X_RC_LEN);
ocCounter.Length = LIB1X_RC_LEN;
ReplayCounter_LI2OC(ocCounter, &global->auth->Dot1xKeyReplayCounter);
memcpy(eapol_key->counter, ocCounter.Octet, LIB1X_RC_LEN);
INCLargeInteger(&global->auth->Dot1xKeyReplayCounter);
//printf("Higg = %d, Low = %d\n", global->auth->Dot1xKeyReplayCounter.field.HighPart,
//global->auth->Dot1xKeyReplayCounter.field.LowPart);
//TODO:Generate Random number as Key IV
memcpy(eapol_key->iv, szIV, LIB1X_IV_LEN);
eapol_key->index = 0;
eapol_key->index |= (EAPOL_GROUP_KEY|EAPOL_GROUP_INDEX);
memcpy(szKeyBuf, szIV, LIB1X_IV_LEN);
memcpy(&szKeyBuf[16], global->RadiusKey.RecvKey.Octet, global->RadiusKey.RecvKey.Length);
RC4_set_key(&rc4key, LIB1X_IV_LEN + global->RadiusKey.RecvKey.Length, szKeyBuf);
//lib1x_hexdump2(MESS_DBG_RAD, "TestFun", szKeyBuf, LIB1X_IV_LEN + global->RadiusKey.RecvKey.Length, "szKeyBuf");
//Need to be removed
/*
memcpy( global->auth->gk_sm->GTK[global->auth->gk_sm->GN] ,
szDefaultKey,
global->RSNVariable.MulticastCipher == DOT11_ENC_WEP40 ? 5:13);
*/
//RC4(&rc4key, ulKeyLen, (u_char*)szDefaultKey, (u_char*)(eapol_key->material));
RC4(&rc4key, ulKeyLen, (u_char*)global->auth->WepGroupKey, (u_char*)(eapol_key->material));
eapol->packet_body_length = htons(LIB1X_EAPOLKEY_HDRLEN + ulKeyLen);
//lib1x_hexdump2(MESS_DBG_KXSM, "lib1x_kxsm_key_transmit", auth_pae->sendBuffer, 100, "snedBuffer");
memset(eapol_key->mic, 0, sizeof(eapol_key->mic));
hmac_md5((u_char*)eapol,
LIB1X_EAPOL_HDRLEN + LIB1X_EAPOLKEY_HDRLEN + ulKeyLen,
global->RadiusKey.SendKey.Octet,
global->RadiusKey.SendKey.Length,
eapol_key->mic);
auth_pae->sendbuflen = ETHER_HDRLEN + LIB1X_EAPOL_HDRLEN + LIB1X_EAPOLKEY_HDRLEN + ulKeyLen;
#ifdef ALLOW_DBG_KXSM
lib1x_hexdump2(MESS_DBG_KXSM, "lib1x_kxsm_key_transmit", auth_pae->sendBuffer, auth_pae->sendbuflen, "Send EAPOL-KEY of Group Key");
#endif
if(global->auth->RSNVariable.MulticastCipher == DOT11_ENC_WEP40 ||
global->auth->RSNVariable.MulticastCipher == DOT11_ENC_WEP104)
lib1x_nal_send( auth_pae->global->TxRx->network_supp, auth_pae->sendBuffer,
auth_pae->sendbuflen );
lib1x_control_SetGTK(global);
//----------------------------------------
//(2)Send Key-mapping-Key
//----------------------------------------
eapol_key = (struct lib1x_eapolkey_dot1x *) ( ( (u_char *) eapol) + LIB1X_EAPOL_HDRLEN );
eapol_key->type = LIB1X_KEY_TYPE_RC4;
lib1x_S2N(ulKeyLen, (u_char*)&eapol_key->length);
ocCounter.Length = LIB1X_RC_LEN;
ReplayCounter_LI2OC(ocCounter, &global->auth->Dot1xKeyReplayCounter);
memcpy(eapol_key->counter, ocCounter.Octet, LIB1X_RC_LEN);
INCLargeInteger(&global->auth->Dot1xKeyReplayCounter);
//printf("Higg = %d, Low = %d\n", global->auth->Dot1xKeyReplayCounter.field.HighPart,
//global->auth->Dot1xKeyReplayCounter.field.LowPart);
//TODO:Generate Random number as Key IV
memcpy(eapol_key->iv, szIV, LIB1X_IV_LEN);
eapol_key->index = 0;
eapol_key->index |= (EAPOL_PAIRWISE_KEY|EAPOL_PAIRWISE_INDEX);
eapol->packet_body_length = htons(LIB1X_EAPOLKEY_HDRLEN);
memset(eapol_key->mic, 0, sizeof(eapol_key->mic));
hmac_md5((u_char*)eapol,
LIB1X_EAPOL_HDRLEN + LIB1X_EAPOLKEY_HDRLEN,
global->RadiusKey.SendKey.Octet,
global->RadiusKey.SendKey.Length,
eapol_key->mic);
auth_pae->sendbuflen = ETHER_HDRLEN + LIB1X_EAPOL_HDRLEN + LIB1X_EAPOLKEY_HDRLEN;
#ifdef ALLOW_DBG_KXSM
lib1x_hexdump2(MESS_DBG_KXSM, "lib1x_kxsm_key_transmit", auth_pae->sendBuffer, auth_pae->sendbuflen, "Send EAPOL-KEY of key-mapping-key");
#endif
if(global->RSNVariable.UnicastCipher == DOT11_ENC_WEP40 ||
global->RSNVariable.UnicastCipher == DOT11_ENC_WEP104)
lib1x_nal_send( auth_pae->global->TxRx->network_supp,
auth_pae->sendBuffer,auth_pae->sendbuflen );
//----Set key-mapping key to driver
//----Key Mapping is for 5280
//lib1x_control_KeyMapping(global, KEYMAP_OPERATION_SET, WEP_MODE_ON_40, KEYMAP_VALID_ON);
//----SetPTK is for software encryption
lib1x_control_SetPORT(global, DOT11_PortStatus_Authorized);
lib1x_control_SetPTK(global);
}
//lib1x_authxmitsm_txKey( auth_pae , global->currentId ); // TODO
auth_pae->sendreplyready = FALSE;
key_sm->keyAvailable = FALSE;
global->RadiusKey.Status = MPPE_SDRCKEY_NONAVALIABLE;
free(ocCounter.Octet);
}
void recv_cb(EV_P_ ev_io *watcher, int revents) {
if(EV_ERROR & revents)
{
printf("error event in read");
return;
}
struct conn_ctx *conn_ctx = (struct conn_ctx *)watcher;
struct conn *conn = conn_ctx->conn;
struct conn *another = conn->another;
char **buf = &another->buf;
if(conn->type == 0) {
ev_timer_again(EV_A_ &conn->recv_ctx->watcher);
} else {
ev_timer_again(EV_A_ &another->recv_ctx->watcher);
}
ssize_t r = recv(conn->fd, *buf, BUFSIZE, 0);
if(debug)
printf("fd %d --------> recv %d\n", conn->fd, r);
if(r == 0) {
close_and_free(EV_A_ conn->another);
close_and_free(EV_A_ conn);
return ;
} else if (r < 0) {
if(errno == EAGAIN || errno == EWOULDBLOCK) {
return ;
} else {
close_and_free(EV_A_ conn->another);
close_and_free(EV_A_ conn);
return ;
}
}
RC4(&conn->key, r, *buf, *buf);
int s = send(another->fd, *buf, r, 0);
if(debug)
printf("send to fd %d --------> %d\n", another->fd, s);
if(s == -1) {
if(errno == EAGAIN || errno == EWOULDBLOCK) {
another->buf_len = r;
another->buf_idx = 0;
ev_io_stop(EV_A_ &conn->recv_ctx->io);
ev_io_start(EV_A_ &another->send_ctx->io);
} else {
close_and_free(EV_A_ conn->another);
close_and_free(EV_A_ conn);
}
return ;
} else if(s < r) {
another->buf_len = r-s;
another->buf_idx = s;
ev_io_stop(EV_A_ &conn->recv_ctx->io);
ev_io_start(EV_A_ &another->send_ctx->io);
}
return ;
}
int main(int argc, char *argv[])
{
FILE *in=NULL,*out=NULL;
char *infile=NULL,*outfile=NULL,*keystr=NULL;
RC4_KEY key;
char buf[BUFSIZ];
int badops=0,i;
char **pp;
unsigned char md[MD5_DIGEST_LENGTH];
argc--;
argv++;
while (argc >= 1)
{
if (strcmp(*argv,"-in") == 0)
{
if (--argc < 1) goto bad;
infile= *(++argv);
}
else if (strcmp(*argv,"-out") == 0)
{
if (--argc < 1) goto bad;
outfile= *(++argv);
}
else if (strcmp(*argv,"-key") == 0)
{
if (--argc < 1) goto bad;
keystr= *(++argv);
}
else
{
fprintf(stderr,"unknown option %s\n",*argv);
badops=1;
break;
}
argc--;
argv++;
}
if (badops)
{
bad:
for (pp=usage; (*pp != NULL); pp++)
fprintf(stderr,*pp);
exit(1);
}
if (infile == NULL)
in=stdin;
else
{
in=fopen(infile,"r");
if (in == NULL)
{
perror("open");
exit(1);
}
}
if (outfile == NULL)
out=stdout;
else
{
out=fopen(outfile,"w");
if (out == NULL)
{
perror("open");
exit(1);
}
}
#ifdef MSDOS
/* This should set the file to binary mode. */
{
#include <fcntl.h>
setmode(fileno(in),O_BINARY);
setmode(fileno(out),O_BINARY);
}
#endif
if (keystr == NULL)
{ /* get key */
i=EVP_read_pw_string(buf,BUFSIZ,"Enter RC4 password:"******"bad password read\n");
exit(1);
}
keystr=buf;
}
MD5((unsigned char *)keystr,(unsigned long)strlen(keystr),md);
OPENSSL_cleanse(keystr,strlen(keystr));
RC4_set_key(&key,MD5_DIGEST_LENGTH,md);
for(;;)
{
i=fread(buf,1,BUFSIZ,in);
if (i == 0) break;
if (i < 0)
{
perror("read");
exit(1);
}
RC4(&key,(unsigned int)i,(unsigned char *)buf,
(unsigned char *)buf);
i=fwrite(buf,(unsigned int)i,1,out);
if (i != 1)
{
perror("write");
exit(1);
}
}
fclose(out);
fclose(in);
exit(0);
return(1);
}
int main(int argc, char *argv[])
{
int i, err = 0;
int j;
unsigned char *p;
RC4_KEY key;
unsigned char obuf[512];
# if !defined(OPENSSL_PIC)
void OPENSSL_cpuid_setup(void);
OPENSSL_cpuid_setup();
# endif
for (i = 0; i < 6; i++) {
RC4_set_key(&key, keys[i][0], &(keys[i][1]));
sgx_memset(obuf, 0x00, sizeof(obuf));
RC4(&key, data_len[i], &(data[i][0]), obuf);
if (sgx_memcmp(obuf, output[i], data_len[i] + 1) != 0) {
printf("error calculating RC4\n");
printf("output:");
for (j = 0; j < data_len[i] + 1; j++)
printf(" %02x", obuf[j]);
printf("\n");
printf("expect:");
p = &(output[i][0]);
for (j = 0; j < data_len[i] + 1; j++)
printf(" %02x", *(p++));
printf("\n");
err++;
} else
printf("test %d ok\n", i);
}
printf("test end processing ");
for (i = 0; i < data_len[3]; i++) {
RC4_set_key(&key, keys[3][0], &(keys[3][1]));
sgx_memset(obuf, 0x00, sizeof(obuf));
RC4(&key, i, &(data[3][0]), obuf);
if ((sgx_memcmp(obuf, output[3], i) != 0) || (obuf[i] != 0)) {
printf("error in RC4 length processing\n");
printf("output:");
for (j = 0; j < i + 1; j++)
printf(" %02x", obuf[j]);
printf("\n");
printf("expect:");
p = &(output[3][0]);
for (j = 0; j < i; j++)
printf(" %02x", *(p++));
printf(" 00\n");
err++;
} else {
printf(".");
fflush(stdout);
}
}
printf("done\n");
printf("test multi-call ");
for (i = 0; i < data_len[3]; i++) {
RC4_set_key(&key, keys[3][0], &(keys[3][1]));
sgx_memset(obuf, 0x00, sizeof(obuf));
RC4(&key, i, &(data[3][0]), obuf);
RC4(&key, data_len[3] - i, &(data[3][i]), &(obuf[i]));
if (sgx_memcmp(obuf, output[3], data_len[3] + 1) != 0) {
printf("error in RC4 multi-call processing\n");
printf("output:");
for (j = 0; j < data_len[3] + 1; j++)
printf(" %02x", obuf[j]);
printf("\n");
printf("expect:");
p = &(output[3][0]);
for (j = 0; j < data_len[3] + 1; j++)
printf(" %02x", *(p++));
err++;
} else {
printf(".");
fflush(stdout);
}
}
printf("done\n");
printf("bulk test ");
{
unsigned char buf[513];
SHA_CTX c;
unsigned char md[SHA_DIGEST_LENGTH];
static unsigned char expected[] = {
0xa4, 0x7b, 0xcc, 0x00, 0x3d, 0xd0, 0xbd, 0xe1, 0xac, 0x5f,
0x12, 0x1e, 0x45, 0xbc, 0xfb, 0x1a, 0xa1, 0xf2, 0x7f, 0xc5
};
RC4_set_key(&key, keys[0][0], &(keys[3][1]));
sgx_memset(buf, '\0', sizeof(buf));
SHA1_Init(&c);
for (i = 0; i < 2571; i++) {
RC4(&key, sizeof(buf), buf, buf);
SHA1_Update(&c, buf, sizeof(buf));
}
SHA1_Final(md, &c);
if (sgx_memcmp(md, expected, sizeof(md))) {
printf("error in RC4 bulk test\n");
printf("output:");
for (j = 0; j < (int)sizeof(md); j++)
printf(" %02x", md[j]);
printf("\n");
printf("expect:");
for (j = 0; j < (int)sizeof(md); j++)
printf(" %02x", expected[j]);
printf("\n");
err++;
} else
printf("ok\n");
}
# ifdef OPENSSL_SYS_NETWARE
if (err)
printf("ERROR: %d\n", err);
# endif
EXIT(err);
return (0);
}
void send_mcast(struct params *p, unsigned char x)
{
struct ieee80211_frame *wh;
short *seq;
struct queue *q = p->q;
char *data, *ptr;
int len;
uLong crc = crc32(0L, Z_NULL, 0);
uLong *pcrc;
int i;
int need_frag = 0;
char payload[10] = "\xAA\xAA\x03\x00\x00\x00\x08\x06\x00\x00";
assert(q);
/* 802.11 */
memset(p->packet, 0, sizeof(p->packet));
wh = (struct ieee80211_frame*) p->packet;
wh->i_fc[0] |= IEEE80211_FC0_TYPE_DATA;
wh->i_fc[0] |= IEEE80211_FC0_SUBTYPE_DATA;
wh->i_fc[1] |= IEEE80211_FC1_DIR_TODS;
wh->i_fc[1] |= IEEE80211_FC1_WEP;
wh->i_dur[0] = 0x69;
memcpy(wh->i_addr1, p->ap, 6);
memcpy(wh->i_addr2, p->mac, 6);
memcpy(wh->i_addr3, p->mcast, 5);
wh->i_addr3[5] = x;
seq = (short*) wh->i_seq;
*seq = seqfn(p->seq++, 0);
/* IV */
data = (char*) (wh+1);
ptr = (char*) (q->wh+1);
memcpy(data, ptr, 3);
if (p->prga_len == 0) {
RC4_KEY k;
unsigned char key[8];
memset(&key[3], 0x61, 5);
memcpy(key, (q->wh+1), 3);
p->prga_len = 128;
RC4_set_key(&k, 8, key);
memset(p->prga, 0, sizeof(p->prga));
RC4(&k, p->prga_len, p->prga, p->prga);
#if 0
int ptl = q->len;
char *pt;
pt = known_pt(q->wh, &ptl);
ptr += 4;
p->prga_len = ptl;
for (i = 0; i < p->prga_len; i++)
p->prga[i] = ptr[i] ^ pt[i];
#endif
}
/* data */
data += 4;
memcpy(data, payload, sizeof(payload));
p->prga_len = 12;
len = p->prga_len + 1 - 4;
#if 1
if (len < sizeof(payload)) {
need_frag = len;
wh->i_fc[1] |= IEEE80211_FC1_MORE_FRAG;
}
#endif
/* crc */
pcrc = (uLong*) (data+len);
*pcrc = crc32(crc, data, len);
/* wepify */
len += 4;
for (i = 0; i < (len); i++) {
assert( i <= p->prga_len);
data[i] ^= p->prga[i];
}
// data[i] ^= x;
len += sizeof(*wh);
p->packet_len = len + 4;
send_packet(p);
/* the data we sent is too f*****g short */
if (need_frag) {
memset(data, 0, len);
/* 802.11 */
*seq = seqfn(p->seq-1, 1);
wh->i_fc[1] &= ~IEEE80211_FC1_MORE_FRAG;
/* data */
len = sizeof(payload) - need_frag;
assert(len > 0 && len <= (p->prga_len - 4));
memcpy(data, &payload[need_frag], len);
/* crc */
crc = crc32(0L, Z_NULL, 0);
len = p->prga_len - 4;
pcrc = (uLong*) (data+len);
*pcrc = crc32(crc, data, len);
/* wepify */
len += 4;
for (i = 0; i < len; i++) {
assert( i < p->prga_len);
data[i] ^= p->prga[i];
}
len += sizeof(*wh) + 4;
p->packet_len = len;
send_packet(p);
}
}
void crypto_rc4(CryptoRc4 rc4, UINT32 length, const BYTE* in_data, BYTE* out_data)
{
RC4(&rc4->rc4_key, length, in_data, out_data);
}
int ssl_test_rc4(int argc, char *argv[])
{
int i,err=0;
int j;
unsigned char *p;
RC4_KEY key;
unsigned char obuf[512];
for (i=0; i<6; i++)
{
RC4_set_key(&key,keys[i][0],&(keys[i][1]));
TINYCLR_SSL_MEMSET(obuf,0x00,sizeof(obuf));
RC4(&key,data_len[i],&(data[i][0]),obuf);
if (TINYCLR_SSL_MEMCMP(obuf,output[i],data_len[i]+1) != 0)
{
TINYCLR_SSL_PRINTF("error calculating RC4\n");
TINYCLR_SSL_PRINTF("output:");
for (j=0; j<data_len[i]+1; j++)
TINYCLR_SSL_PRINTF(" %02x",obuf[j]);
TINYCLR_SSL_PRINTF("\n");
TINYCLR_SSL_PRINTF("expect:");
p= &(output[i][0]);
for (j=0; j<data_len[i]+1; j++)
TINYCLR_SSL_PRINTF(" %02x",*(p++));
TINYCLR_SSL_PRINTF("\n");
err++;
}
else
TINYCLR_SSL_PRINTF("test %d ok\n",i);
}
TINYCLR_SSL_PRINTF("test end processing ");
for (i=0; i<data_len[3]; i++)
{
RC4_set_key(&key,keys[3][0],&(keys[3][1]));
TINYCLR_SSL_MEMSET(obuf,0x00,sizeof(obuf));
RC4(&key,i,&(data[3][0]),obuf);
if ((TINYCLR_SSL_MEMCMP(obuf,output[3],i) != 0) || (obuf[i] != 0))
{
TINYCLR_SSL_PRINTF("error in RC4 length processing\n");
TINYCLR_SSL_PRINTF("output:");
for (j=0; j<i+1; j++)
TINYCLR_SSL_PRINTF(" %02x",obuf[j]);
TINYCLR_SSL_PRINTF("\n");
TINYCLR_SSL_PRINTF("expect:");
p= &(output[3][0]);
for (j=0; j<i; j++)
TINYCLR_SSL_PRINTF(" %02x",*(p++));
TINYCLR_SSL_PRINTF(" 00\n");
err++;
}
else
{
TINYCLR_SSL_PRINTF(".");
TINYCLR_SSL_FFLUSH(OPENSSL_TYPE__FILE_STDOUT);
}
}
TINYCLR_SSL_PRINTF("done\n");
TINYCLR_SSL_PRINTF("test multi-call ");
for (i=0; i<data_len[3]; i++)
{
RC4_set_key(&key,keys[3][0],&(keys[3][1]));
TINYCLR_SSL_MEMSET(obuf,0x00,sizeof(obuf));
RC4(&key,i,&(data[3][0]),obuf);
RC4(&key,data_len[3]-i,&(data[3][i]),&(obuf[i]));
if (TINYCLR_SSL_MEMCMP(obuf,output[3],data_len[3]+1) != 0)
{
TINYCLR_SSL_PRINTF("error in RC4 multi-call processing\n");
TINYCLR_SSL_PRINTF("output:");
for (j=0; j<data_len[3]+1; j++)
TINYCLR_SSL_PRINTF(" %02x",obuf[j]);
TINYCLR_SSL_PRINTF("\n");
TINYCLR_SSL_PRINTF("expect:");
p= &(output[3][0]);
for (j=0; j<data_len[3]+1; j++)
TINYCLR_SSL_PRINTF(" %02x",*(p++));
err++;
}
else
{
TINYCLR_SSL_PRINTF(".");
TINYCLR_SSL_FFLUSH(OPENSSL_TYPE__FILE_STDOUT);
}
}
TINYCLR_SSL_PRINTF("done\n");
TINYCLR_SSL_PRINTF("bulk test ");
{ unsigned char buf[513];
SHA_CTX c;
unsigned char md[SHA_DIGEST_LENGTH];
static unsigned char expected[]={
0xa4,0x7b,0xcc,0x00,0x3d,0xd0,0xbd,0xe1,0xac,0x5f,
0x12,0x1e,0x45,0xbc,0xfb,0x1a,0xa1,0xf2,0x7f,0xc5 };
RC4_set_key(&key,keys[0][0],&(keys[3][1]));
TINYCLR_SSL_MEMSET(buf,'\0',sizeof(buf));
SHA1_Init(&c);
for (i=0;i<2571;i++) {
RC4(&key,sizeof(buf),buf,buf);
SHA1_Update(&c,buf,sizeof(buf));
}
SHA1_Final(md,&c);
if (TINYCLR_SSL_MEMCMP(md,expected,sizeof(md))) {
TINYCLR_SSL_PRINTF("error in RC4 bulk test\n");
TINYCLR_SSL_PRINTF("output:");
for (j=0; j<(int)sizeof(md); j++)
TINYCLR_SSL_PRINTF(" %02x",md[j]);
TINYCLR_SSL_PRINTF("\n");
TINYCLR_SSL_PRINTF("expect:");
for (j=0; j<(int)sizeof(md); j++)
TINYCLR_SSL_PRINTF(" %02x",expected[j]);
TINYCLR_SSL_PRINTF("\n");
err++;
}
else TINYCLR_SSL_PRINTF("ok\n");
}
#ifdef OPENSSL_SYS_NETWARE
if (err) TINYCLR_SSL_PRINTF("ERROR: %d\n", err);
#endif
return(err);
}
