}
if (!challenge_set_by) {
- uchar chal[8];
+ uint8_t chal[8];
generate_random_buffer(chal, sizeof(chal), False);
auth_context->challenge = data_blob_talloc(auth_context->mem_ctx,
Make a auth_info struct with a fixed challenge
***************************************************************************/
-NTSTATUS make_auth_context_fixed(struct auth_context **auth_context, uchar chal[8])
+NTSTATUS make_auth_context_fixed(struct auth_context **auth_context, uint8_t chal[8])
{
NTSTATUS nt_status;
if (!NT_STATUS_IS_OK(nt_status = make_auth_context_subsystem(auth_context))) {
static NTSTATUS domain_client_validate(TALLOC_CTX *mem_ctx,
const auth_usersupplied_info *user_info,
const char *domain,
- uchar chal[8],
+ uint8_t chal[8],
auth_serversupplied_info **server_info,
const char *server, const char *setup_creds_as,
uint16_t sec_chan,
password_server = lp_passwordserver();
nt_status = domain_client_validate(mem_ctx, user_info, domain,
- (uchar *)auth_context->challenge.data,
+ (uint8_t *)auth_context->challenge.data,
server_info,
password_server, lp_netbios_name(), SEC_CHAN_WKSTA, trust_passwd, last_change_time);
return nt_status;
#endif
nt_status = domain_client_validate(mem_ctx, user_info, user_info->domain.str,
- (uchar *)auth_context->challenge.data,
+ (uint8_t *)auth_context->challenge.data,
server_info, "*" /* Do a lookup */,
lp_workgroup(), SEC_CHAN_DOMAIN, trust_md4_password, last_change_time);
const char *smb_name,
const char *client_domain,
const char *wksta_name,
- const uchar *lm_network_pwd, int lm_pwd_len,
- const uchar *nt_network_pwd, int nt_pwd_len)
+ const uint8_t *lm_network_pwd, int lm_pwd_len,
+ const uint8_t *nt_network_pwd, int nt_pwd_len)
{
BOOL ret;
NTSTATUS nt_status;
const char *smb_name,
const char *client_domain,
const char *wksta_name,
- const uchar chal[8],
- const uchar lm_interactive_pwd[16],
- const uchar nt_interactive_pwd[16],
- const uchar *dc_sess_key)
+ const uint8_t chal[8],
+ const uint8_t lm_interactive_pwd[16],
+ const uint8_t nt_interactive_pwd[16],
+ const uint8_t *dc_sess_key)
{
char lm_pwd[16];
char nt_pwd[16];
#endif
if (lm_interactive_pwd)
- SamOEMhash((uchar *)lm_pwd, key, sizeof(lm_pwd));
+ SamOEMhash((uint8_t *)lm_pwd, key, sizeof(lm_pwd));
if (nt_interactive_pwd)
- SamOEMhash((uchar *)nt_pwd, key, sizeof(nt_pwd));
+ SamOEMhash((uint8_t *)nt_pwd, key, sizeof(nt_pwd));
#ifdef DEBUG_PASSWORD
DEBUG(100,("decrypt of lm owf password:"));
dump_data(100, plaintext_password.data, plaintext_password.length);
#endif
- SMBencrypt( (const char *)plaintext_password.data, (const uchar*)chal, local_lm_response);
+ SMBencrypt( (const char *)plaintext_password.data, (const uint8_t *)chal, local_lm_response);
local_lm_blob = data_blob(local_lm_response, 24);
/* We can't do an NT hash here, as the password needs to be
typedef struct
{
struct MD5Context ctx;
- uchar k_ipad[65];
- uchar k_opad[65];
+ uint8_t k_ipad[65];
+ uint8_t k_opad[65];
} HMACMD5Context;
#endif
-#ifndef uchar
-#define uchar unsigned char
-#endif
-
/*
Samba needs type definitions for
int8_t, int16_t, int32_t, int64_t
/***********************************************************************
the rfc 2104 version of hmac_md5 initialisation.
***********************************************************************/
-void hmac_md5_init_rfc2104(uchar* key, int key_len, HMACMD5Context *ctx)
+void hmac_md5_init_rfc2104(uint8_t *key, int key_len, HMACMD5Context *ctx)
{
int i;
/* if key is longer than 64 bytes reset it to key=MD5(key) */
if (key_len > 64)
{
- uchar tk[16];
+ uint8_t tk[16];
struct MD5Context tctx;
MD5Init(&tctx);
/***********************************************************************
the microsoft version of hmac_md5 initialisation.
***********************************************************************/
-void hmac_md5_init_limK_to_64(const uchar* key, int key_len,
+void hmac_md5_init_limK_to_64(const uint8_t *key, int key_len,
HMACMD5Context *ctx)
{
/* if key is longer than 64 bytes truncate it */
/***********************************************************************
update hmac_md5 "inner" buffer
***********************************************************************/
-void hmac_md5_update(const uchar* text, int text_len, HMACMD5Context *ctx)
+void hmac_md5_update(const uint8_t *text, int text_len, HMACMD5Context *ctx)
{
MD5Update(&ctx->ctx, text, text_len); /* then text of datagram */
}
/***********************************************************************
finish off hmac_md5 "inner" buffer and generate outer one.
***********************************************************************/
-void hmac_md5_final(uchar *digest, HMACMD5Context *ctx)
-
+void hmac_md5_final(uint8_t *digest, HMACMD5Context *ctx)
{
struct MD5Context ctx_o;
single function to calculate an HMAC MD5 digest from data.
use the microsoft hmacmd5 init method because the key is 16 bytes.
************************************************************/
-void hmac_md5(const uchar key[16], const uchar *data, int data_len, uchar* digest)
+void hmac_md5(const uint8_t key[16], const uint8_t *data, int data_len, uint8_t *digest)
{
HMACMD5Context ctx;
hmac_md5_init_limK_to_64(key, 16, &ctx);
}
hmac_md5_final(digest, &ctx);
}
-
return False;
}
-void dump_data_pw(const char *msg, const uchar * data, size_t len)
+void dump_data_pw(const char *msg, const uint8_t * data, size_t len)
{
#ifdef DEBUG_PASSWORD
DEBUG(11, ("%s", msg));
****************************************************************************/
static BOOL smb_pwd_check_ntlmv1(const DATA_BLOB *nt_response,
- const uchar *part_passwd,
+ const uint8_t *part_passwd,
const DATA_BLOB *sec_blob,
DATA_BLOB *user_sess_key)
{
/* Finish the encryption of part_passwd. */
- uchar p24[24];
+ uint8_t p24[24];
if (part_passwd == NULL) {
DEBUG(10,("No password set - DISALLOWING access\n"));
****************************************************************************/
static BOOL smb_pwd_check_ntlmv2(const DATA_BLOB *ntv2_response,
- const uchar *part_passwd,
+ const uint8_t *part_passwd,
const DATA_BLOB *sec_blob,
const char *user, const char *domain,
BOOL upper_case_domain, /* should the domain be transformed into upper case? */
DATA_BLOB *user_sess_key)
{
/* Finish the encryption of part_passwd. */
- uchar kr[16];
- uchar value_from_encryption[16];
- uchar client_response[16];
+ uint8_t kr[16];
+ uint8_t value_from_encryption[16];
+ uint8_t client_response[16];
DATA_BLOB client_key_data;
if (part_passwd == NULL) {
username));
} else if (lm_pw && lm_response->length) {
- uchar dospwd[14];
- uchar p16[16];
+ uint8_t dospwd[14];
+ uint8_t p16[16];
ZERO_STRUCT(dospwd);
memcpy(dospwd, lm_response->data, MIN(lm_response->length, sizeof(dospwd)));
static const uint8_t *get_challenge(const struct ntlmssp_state *ntlmssp_state)
{
- static uchar chal[8];
+ static uint8_t chal[8];
generate_random_buffer(chal, sizeof(chal), False);
return chal;
uint32_t ntlmssp_command, auth_flags;
NTSTATUS nt_status;
- uchar session_nonce_hash[16];
+ uint8_t session_nonce_hash[16];
const char *parse_string;
char *domain = NULL;
} else {
/* When there is no LM response, just use zeros */
- static const uchar zeros[24];
+ static const uint8_t zeros[24];
session_key = data_blob_talloc(ntlmssp_state->mem_ctx, NULL, 16);
SMBsesskeygen_lm_sess_key(zeros, zeros,
session_key.data);
char *server_domain;
const char *chal_parse_string;
const char *auth_gen_string;
- uchar lm_hash[16];
+ uint8_t lm_hash[16];
DATA_BLOB lm_response = data_blob(NULL, 0);
DATA_BLOB nt_response = data_blob(NULL, 0);
DATA_BLOB session_key = data_blob(NULL, 0);
}
if (!ntlmssp_state->password) {
- static const uchar zeros[16];
+ static const uint8_t zeros[16];
/* do nothing - blobs are zero length */
/* session key is all zeros */
} else if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_NTLM2) {
struct MD5Context md5_session_nonce_ctx;
- uchar nt_hash[16];
- uchar session_nonce[16];
- uchar session_nonce_hash[16];
- uchar user_session_key[16];
+ uint8_t nt_hash[16];
+ uint8_t session_nonce[16];
+ uint8_t session_nonce_hash[16];
+ uint8_t user_session_key[16];
E_md4hash(ntlmssp_state->password, nt_hash);
lm_response = data_blob_talloc(ntlmssp_state->mem_ctx, NULL, 24);
/* LM Key is incompatible... */
ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_LM_KEY;
} else {
- uchar nt_hash[16];
+ uint8_t nt_hash[16];
if (ntlmssp_state->use_nt_response) {
nt_response = data_blob_talloc(ntlmssp_state->mem_ctx, NULL, 24);
SMBsesskeygen_lm_sess_key(lm_session_key.data, lm_response.data,
new_session_key.data);
} else {
- static const uchar zeros[24];
+ static const uint8_t zeros[24];
SMBsesskeygen_lm_sess_key(lm_session_key.data, zeros,
new_session_key.data);
}
/* internal variables used by NTLM2 */
BOOL doing_ntlm2;
- uchar session_nonce[16];
+ uint8_t session_nonce[16];
/* internal variables used by KEY_EXCH (client-supplied user session key */
DATA_BLOB encrypted_session_key;
static NTSTATUS ntlmssp_make_packet_signature(NTLMSSP_STATE *ntlmssp_state,
TALLOC_CTX *sig_mem_ctx,
- const uchar *data, size_t length,
+ const uint8_t *data, size_t length,
enum ntlmssp_direction direction,
DATA_BLOB *sig)
{
if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_NTLM2) {
HMACMD5Context ctx;
- uchar seq_num[4];
- uchar digest[16];
+ uint8_t seq_num[4];
+ uint8_t digest[16];
SIVAL(seq_num, 0, ntlmssp_state->ntlmssp_seq_num);
switch (direction) {
NTSTATUS ntlmssp_sign_packet(NTLMSSP_STATE *ntlmssp_state,
TALLOC_CTX *sig_mem_ctx,
- const uchar *data, size_t length,
+ const uint8_t *data, size_t length,
DATA_BLOB *sig)
{
NTSTATUS nt_status;
NTSTATUS ntlmssp_check_packet(NTLMSSP_STATE *ntlmssp_state,
TALLOC_CTX *sig_mem_ctx,
- const uchar *data, size_t length,
+ const uint8_t *data, size_t length,
const DATA_BLOB *sig)
{
DATA_BLOB local_sig;
NTSTATUS ntlmssp_seal_packet(NTLMSSP_STATE *ntlmssp_state,
TALLOC_CTX *sig_mem_ctx,
- uchar *data, size_t length,
+ uint8_t *data, size_t length,
DATA_BLOB *sig)
{
if (!ntlmssp_state->session_key.length) {
dump_data_pw("ntlmssp clear data\n", data, length);
if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_NTLM2) {
HMACMD5Context ctx;
- uchar seq_num[4];
- uchar digest[16];
+ uint8_t seq_num[4];
+ uint8_t digest[16];
SIVAL(seq_num, 0, ntlmssp_state->ntlmssp_seq_num);
hmac_md5_init_limK_to_64(ntlmssp_state->send_sign_key,
NTSTATUS ntlmssp_unseal_packet(NTLMSSP_STATE *ntlmssp_state,
TALLOC_CTX *sig_mem_ctx,
- uchar *data, size_t length,
+ uint8_t *data, size_t length,
DATA_BLOB *sig)
{
if (!ntlmssp_state->session_key.length) {
Encode or Decode the sequence number (which is symmetric)
********************************************************************/
static void netsec_deal_with_seq_num(struct schannel_state *state,
- const uchar packet_digest[8],
- uchar seq_num[8])
+ const uint8_t packet_digest[8],
+ uint8_t seq_num[8])
{
- static const uchar zeros[4];
- uchar sequence_key[16];
- uchar digest1[16];
+ static const uint8_t zeros[4];
+ uint8_t sequence_key[16];
+ uint8_t digest1[16];
hmac_md5(state->session_key, zeros, sizeof(zeros), digest1);
hmac_md5(digest1, packet_digest, 8, sequence_key);
/*******************************************************************
Calculate the key with which to encode the data payload
********************************************************************/
-static void netsec_get_sealing_key(const uchar session_key[16],
- const uchar seq_num[8],
- uchar sealing_key[16])
+static void netsec_get_sealing_key(const uint8_t session_key[16],
+ const uint8_t seq_num[8],
+ uint8_t sealing_key[16])
{
- static const uchar zeros[4];
- uchar digest2[16];
- uchar sess_kf0[16];
+ static const uint8_t zeros[4];
+ uint8_t digest2[16];
+ uint8_t sess_kf0[16];
int i;
for (i = 0; i < 16; i++) {
Create a digest over the entire packet (including the data), and
MD5 it with the session key.
********************************************************************/
-static void schannel_digest(const uchar sess_key[16],
- const uchar netsec_sig[8],
- const uchar *confounder,
- const uchar *data, size_t data_len,
- uchar digest_final[16])
+static void schannel_digest(const uint8_t sess_key[16],
+ const uint8_t netsec_sig[8],
+ const uint8_t *confounder,
+ const uint8_t *data, size_t data_len,
+ uint8_t digest_final[16])
{
- uchar packet_digest[16];
- static const uchar zeros[4];
+ uint8_t packet_digest[16];
+ static const uint8_t zeros[4];
struct MD5Context ctx;
MD5Init(&ctx);
*/
NTSTATUS schannel_unseal_packet(struct schannel_state *state,
TALLOC_CTX *mem_ctx,
- uchar *data, size_t length,
+ uint8_t *data, size_t length,
DATA_BLOB *sig)
{
- uchar digest_final[16];
- uchar confounder[8];
- uchar seq_num[8];
- uchar sealing_key[16];
- static const uchar netsec_sig[8] = NETSEC_SEAL_SIGNATURE;
+ uint8_t digest_final[16];
+ uint8_t confounder[8];
+ uint8_t seq_num[8];
+ uint8_t sealing_key[16];
+ static const uint8_t netsec_sig[8] = NETSEC_SEAL_SIGNATURE;
if (sig->length != 32) {
return NT_STATUS_ACCESS_DENIED;
check the signature on a packet
*/
NTSTATUS schannel_check_packet(struct schannel_state *state,
- const uchar *data, size_t length,
+ const uint8_t *data, size_t length,
const DATA_BLOB *sig)
{
- uchar digest_final[16];
- uchar seq_num[8];
- static const uchar netsec_sig[8] = NETSEC_SIGN_SIGNATURE;
+ uint8_t digest_final[16];
+ uint8_t seq_num[8];
+ static const uint8_t netsec_sig[8] = NETSEC_SIGN_SIGNATURE;
if (sig->length != 32) {
return NT_STATUS_ACCESS_DENIED;
*/
NTSTATUS schannel_seal_packet(struct schannel_state *state,
TALLOC_CTX *mem_ctx,
- uchar *data, size_t length,
+ uint8_t *data, size_t length,
DATA_BLOB *sig)
{
- uchar digest_final[16];
- uchar confounder[8];
- uchar seq_num[8];
- uchar sealing_key[16];
- static const uchar netsec_sig[8] = NETSEC_SEAL_SIGNATURE;
+ uint8_t digest_final[16];
+ uint8_t confounder[8];
+ uint8_t seq_num[8];
+ uint8_t sealing_key[16];
+ static const uint8_t netsec_sig[8] = NETSEC_SEAL_SIGNATURE;
generate_random_buffer(confounder, 8, False);
*/
NTSTATUS schannel_sign_packet(struct schannel_state *state,
TALLOC_CTX *mem_ctx,
- const uchar *data, size_t length,
+ const uint8_t *data, size_t length,
DATA_BLOB *sig)
{
- uchar digest_final[16];
- uchar seq_num[8];
- static const uchar netsec_sig[8] = NETSEC_SIGN_SIGNATURE;
+ uint8_t digest_final[16];
+ uint8_t seq_num[8];
+ static const uint8_t netsec_sig[8] = NETSEC_SIGN_SIGNATURE;
RSIVAL(seq_num, 0, state->seq_num);
SIVAL(seq_num, 4, state->initiator?0x80:0);
struct in_addr ip;
int bits1, bits2;
ip = *iface_n_bcast(i);
- bits1 = matching_quad_bits((uchar *)&ip1->s_addr, (uchar *)&ip.s_addr);
- bits2 = matching_quad_bits((uchar *)&ip2->s_addr, (uchar *)&ip.s_addr);
+ bits1 = matching_quad_bits((uint8_t *)&ip1->s_addr, (uint8_t *)&ip.s_addr);
+ bits2 = matching_quad_bits((uint8_t *)&ip2->s_addr, (uint8_t *)&ip.s_addr);
max_bits1 = MAX(bits1, max_bits1);
max_bits2 = MAX(bits2, max_bits2);
}
for (j = 0; j < 16; j++)
{
- uchar x = res->rdata[i+j];
+ uint8_t x = res->rdata[i+j];
if (x < 32 || x > 127) x = '.';
if (i+j >= res->rdlength) break;
for (j = 0; j < 16; j++)
{
if (i+j >= res->rdlength) break;
- DEBUGADD(4, ("%02X", (uchar)res->rdata[i+j]));
+ DEBUGADD(4, ("%02X", (uint8_t)res->rdata[i+j]));
}
DEBUGADD(4, ("\n"));
/*******************************************************************
handle "compressed" name pointers
******************************************************************/
-static BOOL handle_name_ptrs(uchar *ubuf,int *offset,int length,
+static BOOL handle_name_ptrs(uint8_t *ubuf,int *offset,int length,
BOOL *got_pointer,int *ret)
{
int loop_count=0;
static int parse_nmb_name(char *inbuf,int ofs,int length, struct nmb_name *name)
{
int m,n=0;
- uchar *ubuf = (uchar *)inbuf;
+ uint8_t *ubuf = (uint8_t *)inbuf;
int ret = 0;
BOOL got_pointer=False;
int loop_count=0;
ret += m + 2;
offset++;
while (m > 0) {
- uchar c1,c2;
+ uint8_t c1,c2;
c1 = ubuf[offset++]-'A';
c2 = ubuf[offset++]-'A';
if ((c1 & 0xF0) || (c2 & 0xF0) || (n > sizeof(name->name)-1))
if (n==16) {
/* parse out the name type,
its always in the 16th byte of the name */
- name->name_type = ((uchar)name->name[15]) & 0xff;
+ name->name_type = ((uint8_t)name->name[15]) & 0xff;
/* remove trailing spaces */
name->name[15] = 0;
/*******************************************************************
put a compressed name pointer record into a packet
******************************************************************/
-static int put_compressed_name_ptr(uchar *buf,int offset,struct res_rec *rec,int ptr_offset)
+static int put_compressed_name_ptr(uint8_t *buf,int offset,struct res_rec *rec,int ptr_offset)
{
int ret=0;
buf[offset] = (0xC0 | ((ptr_offset >> 8) & 0xFF));
static int build_dgram(char *buf,struct packet_struct *p)
{
struct dgram_packet *dgram = &p->packet.dgram;
- uchar *ubuf = (uchar *)buf;
+ uint8_t *ubuf = (uint8_t *)buf;
int offset=0;
/* put in the header */
static int build_nmb(char *buf,struct packet_struct *p)
{
struct nmb_packet *nmb = &p->packet.nmb;
- uchar *ubuf = (uchar *)buf;
+ uint8_t *ubuf = (uint8_t *)buf;
int offset=0;
/* put in the header */
/****************************************************************************
return the number of bits that match between two 4 character buffers
***************************************************************************/
-int matching_quad_bits(uchar *p1, uchar *p2)
+int matching_quad_bits(uint8_t *p1, uint8_t *p2)
{
int i, j, ret = 0;
for (i=0; i<4; i++) {
}
-static uchar sort_ip[4];
+static uint8_t sort_ip[4];
/****************************************************************************
compare two query reply records
***************************************************************************/
-static int name_query_comp(uchar *p1, uchar *p2)
+static int name_query_comp(uint8_t *p1, uint8_t *p2)
{
return matching_quad_bits(p2+2, sort_ip) - matching_quad_bits(p1+2, sort_ip);
}
while(*in)
{
*out++ = '.'; /* Scope names are separated by periods */
- len = *(uchar *)in++;
+ len = *(uint8_t *)in++;
StrnCpy(out, in, len);
out += len;
*out=0;
****************************************************************************/
static char *name_ptr(char *buf,int ofs)
{
- uchar c = *(uchar *)(buf+ofs);
+ uint8_t c = *(uint8_t *)(buf+ofs);
if ((c & 0xC0) == 0xC0)
{
int name_len(char *s1)
{
/* NOTE: this argument _must_ be unsigned */
- uchar *s = (uchar *)s1;
+ uint8_t *s = (uint8_t *)s1;
int len;
/* If the two high bits of the byte are set, return 2. */
const char *password, const DATA_BLOB *nt_response)
{
struct cli_transport *transport = session->transport;
- uchar nt_hash[16];
+ uint8_t nt_hash[16];
DATA_BLOB session_key = data_blob(NULL, 16);
E_md4hash(password, nt_hash);
*/
-#define uchar unsigned char
+#define uint8_t unsigned char
-static const uchar perm1[56] = {57, 49, 41, 33, 25, 17, 9,
+static const uint8_t perm1[56] = {57, 49, 41, 33, 25, 17, 9,
1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27,
19, 11, 3, 60, 52, 44, 36,
14, 6, 61, 53, 45, 37, 29,
21, 13, 5, 28, 20, 12, 4};
-static const uchar perm2[48] = {14, 17, 11, 24, 1, 5,
+static const uint8_t perm2[48] = {14, 17, 11, 24, 1, 5,
3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8,
16, 7, 27, 20, 13, 2,
44, 49, 39, 56, 34, 53,
46, 42, 50, 36, 29, 32};
-static const uchar perm3[64] = {58, 50, 42, 34, 26, 18, 10, 2,
+static const uint8_t perm3[64] = {58, 50, 42, 34, 26, 18, 10, 2,
60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6,
64, 56, 48, 40, 32, 24, 16, 8,
61, 53, 45, 37, 29, 21, 13, 5,
63, 55, 47, 39, 31, 23, 15, 7};
-static const uchar perm4[48] = { 32, 1, 2, 3, 4, 5,
+static const uint8_t perm4[48] = { 32, 1, 2, 3, 4, 5,
4, 5, 6, 7, 8, 9,
8, 9, 10, 11, 12, 13,
12, 13, 14, 15, 16, 17,
24, 25, 26, 27, 28, 29,
28, 29, 30, 31, 32, 1};
-static const uchar perm5[32] = { 16, 7, 20, 21,
+static const uint8_t perm5[32] = { 16, 7, 20, 21,
29, 12, 28, 17,
1, 15, 23, 26,
5, 18, 31, 10,
22, 11, 4, 25};
-static const uchar perm6[64] ={ 40, 8, 48, 16, 56, 24, 64, 32,
+static const uint8_t perm6[64] ={ 40, 8, 48, 16, 56, 24, 64, 32,
39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30,
37, 5, 45, 13, 53, 21, 61, 29,
33, 1, 41, 9, 49, 17, 57, 25};
-static const uchar sc[16] = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};
+static const uint8_t sc[16] = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};
-static const uchar sbox[8][4][16] = {
+static const uint8_t sbox[8][4][16] = {
{{14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7},
{0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8},
{4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0},
{7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8},
{2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11}}};
-static void permute(char *out, const char *in, const uchar *p, int n)
+static void permute(char *out, const char *in, const uint8_t *p, int n)
{
int i;
for (i=0;i<n;i++)
/* Decode a sam password hash into a password. The password hash is the
same method used to store passwords in the NT registry. The DES key
used is based on the RID of the user. */
-void sam_pwd_hash(uint_t rid, const uchar *in, uchar *out, int forw)
+void sam_pwd_hash(uint_t rid, const uint8_t *in, uint8_t *out, int forw)
{
- uchar s[14];
+ uint8_t s[14];
- s[0] = s[4] = s[8] = s[12] = (uchar)(rid & 0xFF);
- s[1] = s[5] = s[9] = s[13] = (uchar)((rid >> 8) & 0xFF);
- s[2] = s[6] = s[10] = (uchar)((rid >> 16) & 0xFF);
- s[3] = s[7] = s[11] = (uchar)((rid >> 24) & 0xFF);
+ s[0] = s[4] = s[8] = s[12] = (uint8_t)(rid & 0xFF);
+ s[1] = s[5] = s[9] = s[13] = (uint8_t)((rid >> 8) & 0xFF);
+ s[2] = s[6] = s[10] = (uint8_t)((rid >> 16) & 0xFF);
+ s[3] = s[7] = s[11] = (uint8_t)((rid >> 24) & 0xFF);
smbhash(out, in, s, forw);
smbhash(out+8, in+8, s+7, forw);
Returns False if password must have been truncated to create LM hash
*/
-BOOL SMBencrypt(const char *passwd, const uchar *c8, uchar p24[24])
+BOOL SMBencrypt(const char *passwd, const uint8_t *c8, uint8_t p24[24])
{
BOOL ret;
- uchar p21[21];
+ uint8_t p21[21];
memset(p21,'\0',21);
ret = E_deshash(passwd, p21);
* @param p16 return password hashed with md4, caller allocated 16 byte buffer
*/
-void E_md4hash(const char *passwd, uchar p16[16])
+void E_md4hash(const char *passwd, uint8_t p16[16])
{
int len;
smb_ucs2_t wpwd[129];
* @note p16 is filled in regardless
*/
-BOOL E_deshash(const char *passwd, uchar p16[16])
+BOOL E_deshash(const char *passwd, uint8_t p16[16])
{
BOOL ret = True;
fstring dospwd;
*/
/* Does both the NT and LM owfs of a user's password */
-void nt_lm_owf_gen(const char *pwd, uchar nt_p16[16], uchar p16[16])
+void nt_lm_owf_gen(const char *pwd, uint8_t nt_p16[16], uint8_t p16[16])
{
/* Calculate the MD4 hash (NT compatible) of the password */
memset(nt_p16, '\0', 16);
dump_data(100, (char *)nt_p16, 16);
#endif
- E_deshash(pwd, (uchar *)p16);
+ E_deshash(pwd, (uint8_t *)p16);
#ifdef DEBUG_PASSWORD
DEBUG(100,("nt_lm_owf_gen: pwd, lm#\n"));
}
/* Does both the NTLMv2 owfs of a user's password */
-BOOL ntv2_owf_gen(const uchar owf[16],
+BOOL ntv2_owf_gen(const uint8_t owf[16],
const char *user_in, const char *domain_in,
BOOL upper_case_domain, /* Transform the domain into UPPER case */
- uchar kr_buf[16])
+ uint8_t kr_buf[16])
{
smb_ucs2_t *user;
smb_ucs2_t *domain;
}
/* Does the des encryption from the NT or LM MD4 hash. */
-void SMBOWFencrypt(const uchar passwd[16], const uchar *c8, uchar p24[24])
+void SMBOWFencrypt(const uint8_t passwd[16], const uint8_t *c8, uint8_t p24[24])
{
- uchar p21[21];
+ uint8_t p21[21];
ZERO_STRUCT(p21);
/* Does the NT MD4 hash then des encryption. */
-void SMBNTencrypt(const char *passwd, uchar *c8, uchar *p24)
+void SMBNTencrypt(const char *passwd, uint8_t *c8, uint8_t *p24)
{
- uchar p21[21];
+ uint8_t p21[21];
memset(p21,'\0',21);
}
/* Does the md5 encryption from the Key Response for NTLMv2. */
-void SMBOWFencrypt_ntv2(const uchar kr[16],
+void SMBOWFencrypt_ntv2(const uint8_t kr[16],
const DATA_BLOB *srv_chal,
const DATA_BLOB *cli_chal,
- uchar resp_buf[16])
+ uint8_t resp_buf[16])
{
HMACMD5Context ctx;
#endif
}
-void SMBsesskeygen_ntv2(const uchar kr[16],
- const uchar * nt_resp, uint8_t sess_key[16])
+void SMBsesskeygen_ntv2(const uint8_t kr[16],
+ const uint8_t * nt_resp, uint8_t sess_key[16])
{
/* a very nice, 128 bit, variable session key */
#endif
}
-void SMBsesskeygen_ntv1(const uchar kr[16], uint8_t sess_key[16])
+void SMBsesskeygen_ntv1(const uint8_t kr[16], uint8_t sess_key[16])
{
/* yes, this session key does not change - yes, this
is a problem - but it is 128 bits */
#endif
}
-void SMBsesskeygen_lm_sess_key(const uchar lm_hash[16],
- const uchar lm_resp[24], /* only uses 8 */
+void SMBsesskeygen_lm_sess_key(const uint8_t lm_hash[16],
+ const uint8_t lm_resp[24], /* only uses 8 */
uint8_t sess_key[16])
{
/* Calculate the LM session key (effective length 40 bits,
but changes with each session) */
- uchar p24[24];
- uchar p21[21];
+ uint8_t p24[24];
+ uint8_t p21[21];
memset(p21,'\0',21);
memcpy(p21, lm_hash, 8);
static DATA_BLOB NTLMv2_generate_client_data(TALLOC_CTX *mem_ctx, const DATA_BLOB *names_blob)
{
- uchar client_chal[8];
+ uint8_t client_chal[8];
DATA_BLOB response = data_blob(NULL, 0);
char long_date[8];
NTTIME nttime;
return response;
}
-static DATA_BLOB NTLMv2_generate_response(const uchar ntlm_v2_hash[16],
+static DATA_BLOB NTLMv2_generate_response(const uint8_t ntlm_v2_hash[16],
const DATA_BLOB *server_chal,
const DATA_BLOB *names_blob)
{
- uchar ntlmv2_response[16];
+ uint8_t ntlmv2_response[16];
DATA_BLOB ntlmv2_client_data;
DATA_BLOB final_response;
return final_response;
}
-static DATA_BLOB LMv2_generate_response(const uchar ntlm_v2_hash[16],
+static DATA_BLOB LMv2_generate_response(const uint8_t ntlm_v2_hash[16],
const DATA_BLOB *server_chal)
{
- uchar lmv2_response[16];
+ uint8_t lmv2_response[16];
DATA_BLOB lmv2_client_data = data_blob(NULL, 8);
DATA_BLOB final_response = data_blob(NULL, 24);
DATA_BLOB *lm_response, DATA_BLOB *nt_response,
DATA_BLOB *user_session_key)
{
- uchar nt_hash[16];
- uchar ntlm_v2_hash[16];
+ uint8_t nt_hash[16];
+ uint8_t ntlm_v2_hash[16];
E_md4hash(password, nt_hash);
/* We don't use the NT# directly. Instead we use it mashed up with
************************************************************/
BOOL encode_pw_buffer(char buffer[516], const char *password, int string_flags)
{
- uchar new_pw[512];
+ uint8_t new_pw[512];
size_t new_pw_len;
new_pw_len = push_string(NULL, new_pw,
void *private;
NTSTATUS (*unseal_packet)(struct dcerpc_security *,
TALLOC_CTX *mem_ctx,
- uchar *data, size_t length, DATA_BLOB *sig);
+ uint8_t *data, size_t length, DATA_BLOB *sig);
NTSTATUS (*check_packet)(struct dcerpc_security *,
TALLOC_CTX *mem_ctx,
- const uchar *data, size_t length, const DATA_BLOB *sig);
+ const uint8_t *data, size_t length, const DATA_BLOB *sig);
NTSTATUS (*seal_packet)(struct dcerpc_security *,
TALLOC_CTX *mem_ctx,
- uchar *data, size_t length, DATA_BLOB *sig);
+ uint8_t *data, size_t length, DATA_BLOB *sig);
NTSTATUS (*sign_packet)(struct dcerpc_security *,
TALLOC_CTX *mem_ctx,
- const uchar *data, size_t length, DATA_BLOB *sig);
+ const uint8_t *data, size_t length, DATA_BLOB *sig);
NTSTATUS (*session_key)(struct dcerpc_security *, DATA_BLOB *session_key);
void (*security_end)(struct dcerpc_security *);
};
*/
static NTSTATUS ntlm_unseal_packet(struct dcerpc_security *dcerpc_security,
TALLOC_CTX *mem_ctx,
- uchar *data, size_t length, DATA_BLOB *sig)
+ uint8_t *data, size_t length, DATA_BLOB *sig)
{
struct ntlmssp_state *ntlmssp_state = dcerpc_security->private;
return ntlmssp_unseal_packet(ntlmssp_state, mem_ctx, data, length, sig);
static NTSTATUS ntlm_check_packet(struct dcerpc_security *dcerpc_security,
TALLOC_CTX *mem_ctx,
- const uchar *data, size_t length,
+ const uint8_t *data, size_t length,
const DATA_BLOB *sig)
{
struct ntlmssp_state *ntlmssp_state = dcerpc_security->private;
static NTSTATUS ntlm_seal_packet(struct dcerpc_security *dcerpc_security,
TALLOC_CTX *mem_ctx,
- uchar *data, size_t length,
+ uint8_t *data, size_t length,
DATA_BLOB *sig)
{
struct ntlmssp_state *ntlmssp_state = dcerpc_security->private;
static NTSTATUS ntlm_sign_packet(struct dcerpc_security *dcerpc_security,
TALLOC_CTX *mem_ctx,
- const uchar *data, size_t length,
+ const uint8_t *data, size_t length,
DATA_BLOB *sig)
{
struct ntlmssp_state *ntlmssp_state = dcerpc_security->private;
*/
static NTSTATUS schan_unseal_packet(struct dcerpc_security *dcerpc_security,
TALLOC_CTX *mem_ctx,
- uchar *data, size_t length, DATA_BLOB *sig)
+ uint8_t *data, size_t length, DATA_BLOB *sig)
{
struct schannel_state *schannel_state = dcerpc_security->private;
return schannel_unseal_packet(schannel_state, mem_ctx, data, length, sig);
static NTSTATUS schan_check_packet(struct dcerpc_security *dcerpc_security,
TALLOC_CTX *mem_ctx,
- const uchar *data, size_t length,
+ const uint8_t *data, size_t length,
const DATA_BLOB *sig)
{
struct schannel_state *schannel_state = dcerpc_security->private;
static NTSTATUS schan_seal_packet(struct dcerpc_security *dcerpc_security,
TALLOC_CTX *mem_ctx,
- uchar *data, size_t length,
+ uint8_t *data, size_t length,
DATA_BLOB *sig)
{
struct schannel_state *schannel_state = dcerpc_security->private;
static NTSTATUS schan_sign_packet(struct dcerpc_security *dcerpc_security,
TALLOC_CTX *mem_ctx,
- const uchar *data, size_t length,
+ const uint8_t *data, size_t length,
DATA_BLOB *sig)
{
struct schannel_state *schannel_state = dcerpc_security->private;
DATA_BLOB nt_response = data_blob_talloc(samlogon_state->mem_ctx, NULL, 24);
DATA_BLOB session_key = data_blob_talloc(samlogon_state->mem_ctx, NULL, 16);
- uchar lm_key[8];
- uchar user_session_key[16];
- uchar lm_hash[16];
- uchar nt_hash[16];
+ uint8_t lm_key[8];
+ uint8_t user_session_key[16];
+ uint8_t lm_hash[16];
+ uint8_t nt_hash[16];
ZERO_STRUCT(lm_key);
ZERO_STRUCT(user_session_key);
NTSTATUS nt_status;
DATA_BLOB nt_response = data_blob_talloc(samlogon_state->mem_ctx, NULL, 24);
- uchar lm_key[8];
- uchar lm_hash[16];
- uchar user_session_key[16];
+ uint8_t lm_key[8];
+ uint8_t lm_hash[16];
+ uint8_t user_session_key[16];
ZERO_STRUCT(user_session_key);
DATA_BLOB ntlmv2_session_key = data_blob(NULL, 0);
DATA_BLOB names_blob = NTLMv2_generate_names_blob(samlogon_state->mem_ctx, lp_netbios_name(), lp_workgroup());
- uchar user_session_key[16];
+ uint8_t user_session_key[16];
ZERO_STRUCT(user_session_key);
char *dospw;
smb_ucs2_t *unicodepw;
- uchar user_session_key[16];
- uchar lm_key[16];
- static const uchar zeros[8];
+ uint8_t user_session_key[16];
+ uint8_t lm_key[16];
+ static const uint8_t zeros[8];
DATA_BLOB chall = data_blob_talloc(samlogon_state->mem_ctx, zeros, sizeof(zeros));
ZERO_STRUCT(user_session_key);
int fnum1;
int fnum2;
int i;
- uchar buf[131072];
- uchar buf_rd[131072];
+ uint8_t buf[131072];
+ uint8_t buf_rd[131072];
BOOL correct = True;
ssize_t bytes_read, bytes_written;
int net_rpc_join_ok(const char *domain)
{
struct cli_state *cli;
- uchar stored_md4_trust_password[16];
+ uint8_t stored_md4_trust_password[16];
int retval = 1;
uint32_t channel;
NTSTATUS result;
char *clear_trust_password = NULL;
fstring ucs2_trust_password;
int ucs2_pw_len;
- uchar pwbuf[516], sess_key[16];
+ uint8_t pwbuf[516], sess_key[16];
SAM_USERINFO_CTR ctr;
SAM_USER_INFO_24 p24;
SAM_USER_INFO_10 p10;
static void display_account_info(uint32_t rid, SAM_ACCOUNT_INFO *a)
{
fstring hex_nt_passwd, hex_lm_passwd;
- uchar lm_passwd[16], nt_passwd[16];
- static uchar zero_buf[16];
+ uint8_t lm_passwd[16], nt_passwd[16];
+ static uint8_t zero_buf[16];
/* Decode hashes from password hash (if they are not NULL) */
{
NTSTATUS result;
struct cli_state *cli = NULL;
- uchar trust_password[16];
+ uint8_t trust_password[16];
DOM_CRED ret_creds;
uint32_t neg_flags = 0x000001ff;
sam_account_from_delta(SAM_ACCOUNT *account, SAM_ACCOUNT_INFO *delta)
{
fstring s;
- uchar lm_passwd[16], nt_passwd[16];
- static uchar zero_buf[16];
+ uint8_t lm_passwd[16], nt_passwd[16];
+ static uint8_t zero_buf[16];
/* Username, fullname, home dir, dir drive, logon script, acct
desc, workstations, profile. */
{
NTSTATUS result;
struct cli_state *cli = NULL;
- uchar trust_password[16];
+ uint8_t trust_password[16];
DOM_CRED ret_creds;
uint32_t neg_flags = 0x000001ff;
DOM_SID dom_sid;
git.samba.org / nivanova / samba-autobuild / .git / commitdiff