~drizzle-trunk/drizzle/development : contents of libdrizzle/pack.c at revision 1722

~drizzle-trunk/drizzle/development : (revision 1722)

/*
 * Drizzle Client & Protocol Library
 *
 * Copyright (C) 2008 Eric Day (eday@oddments.org)
 * All rights reserved.
 *
 * Use and distribution licensed under the BSD license.  See
 * the COPYING file in this directory for full text.
 */

/**
 * @file
 * @brief Packing definitions
 */

#include "common.h"

/*
 * Private declarations
 */

/**
 * @addtogroup drizzle_pack_private Private Packing Functions
 * @ingroup drizzle_pack
 * @{
 */

/**
 * Compute hash from password and scramble.
 */
static drizzle_return_t _pack_scramble_hash(drizzle_con_st *con,
                                            uint8_t *buffer);

/** @} */

/*
 * Public definitions
 */

uint8_t *drizzle_pack_length(uint64_t number, uint8_t *ptr)
{
  if (number < 251)
  {
    ptr[0]= (uint8_t)number;
    ptr++;
  }
  else if (number < 65536)
  {
    ptr[0]= 252;
    ptr++;
    drizzle_set_byte2(ptr, number);
    ptr+= 2;
  }
  else if (number < 16777216)
  {
    ptr[0]= 253;
    ptr++;
    drizzle_set_byte3(ptr, number);
    ptr+= 3;
  }
  else
  {
    ptr[0]= 254;
    ptr++;
    drizzle_set_byte8(ptr, number);
    ptr+= 8;
  }

  return ptr;
}

uint64_t drizzle_unpack_length(drizzle_con_st *con, drizzle_return_t *ret_ptr)
{
  uint64_t length;
  uint8_t bytes;

  if (con->buffer_ptr[0] < 251)
  {
    length= (uint64_t)(con->buffer_ptr[0]);
    bytes= 1;
  }
  else if (con->buffer_ptr[0] == 251)
  {
    con->buffer_ptr++;
    con->buffer_size--;
    con->packet_size--;

    *ret_ptr= DRIZZLE_RETURN_NULL_SIZE;
    return 0;
  }
  else if (con->buffer_ptr[0] == 252 && con->buffer_size > 2)
  {
    length= drizzle_get_byte2(con->buffer_ptr + 1);
    bytes= 3;
  }
  else if (con->buffer_ptr[0] == 253 && con->buffer_size > 3)
  {
    length= drizzle_get_byte3(con->buffer_ptr + 1);
    bytes= 4;
  }
  else if (con->buffer_size > 8)
  {
    length= drizzle_get_byte8(con->buffer_ptr + 1);
    bytes= 9;
  }
  else
  {
    *ret_ptr= DRIZZLE_RETURN_IO_WAIT;
    return 0;
  }

  con->buffer_ptr+= bytes;
  con->buffer_size-= bytes;
  con->packet_size-= bytes;

  *ret_ptr= DRIZZLE_RETURN_OK;
  return length;
}

uint8_t *drizzle_pack_string(char *string, uint8_t *ptr)
{
  uint64_t size= strlen(string);

  ptr= drizzle_pack_length(size, ptr);
  if (size > 0)
  {
    memcpy(ptr, string, (size_t)size);
    ptr+= size;
  }

  return ptr;
}

drizzle_return_t drizzle_unpack_string(drizzle_con_st *con, char *buffer,
                                       uint64_t max_length)
{
  drizzle_return_t ret= DRIZZLE_RETURN_OK;
  uint64_t length;

  length= drizzle_unpack_length(con, &ret);
  if (ret != DRIZZLE_RETURN_OK)
  {
    if (ret == DRIZZLE_RETURN_NULL_SIZE)
    {
      drizzle_set_error(con->drizzle, "drizzle_unpack_string",
                        "unexpected NULL length");
    }

    return ret;
  }

  if (length < max_length)
  {
    if (length > 0)
      memcpy(buffer, con->buffer_ptr, (size_t)length);

    buffer[length]= 0;
  }
  else
  {
    memcpy(buffer, con->buffer_ptr, (size_t)(max_length - 1));
    buffer[max_length - 1]= 0;
  }
  
  con->buffer_ptr+= length;
  con->buffer_size-= (size_t)length;
  con->packet_size-= (size_t)length;

  return DRIZZLE_RETURN_OK;
}

uint8_t *drizzle_pack_auth(drizzle_con_st *con, uint8_t *ptr,
                           drizzle_return_t *ret_ptr)
{
  if (con->user[0] != 0)
  {
    memcpy(ptr, con->user, strlen(con->user));
    ptr+= strlen(con->user);
  }

  ptr[0]= 0;
  ptr++;

  if (con->options & DRIZZLE_CON_RAW_SCRAMBLE && con->scramble != NULL)
  {
    ptr[0]= DRIZZLE_MAX_SCRAMBLE_SIZE;
    ptr++;

    memcpy(ptr, con->scramble, DRIZZLE_MAX_SCRAMBLE_SIZE);
    ptr+= DRIZZLE_MAX_SCRAMBLE_SIZE;
  }
  else if (con->password[0] == 0)
  {
    ptr[0]= 0;
    ptr++;
    con->packet_size-= DRIZZLE_MAX_SCRAMBLE_SIZE;
  }
  else
  {
    ptr[0]= DRIZZLE_MAX_SCRAMBLE_SIZE;
    ptr++;

    if (con->options & DRIZZLE_CON_MYSQL)
    {
      *ret_ptr= _pack_scramble_hash(con, ptr);
      if (*ret_ptr != DRIZZLE_RETURN_OK)
        return ptr;
    }
    else
      snprintf((char *)ptr, DRIZZLE_MAX_SCRAMBLE_SIZE, "%s", con->password);

    ptr+= DRIZZLE_MAX_SCRAMBLE_SIZE;
  }

  if (con->db[0] != 0)
  {
    memcpy(ptr, con->db, strlen(con->db));
    ptr+= strlen(con->db);
  }

  ptr[0]= 0;
  ptr++;

  *ret_ptr= DRIZZLE_RETURN_OK;
  return ptr;
}

/*
 * Private definitions
 */

static drizzle_return_t _pack_scramble_hash(drizzle_con_st *con,
                                            uint8_t *buffer)
{
  SHA1_CTX ctx;
  uint8_t hash_tmp1[SHA1_DIGEST_LENGTH];
  uint8_t hash_tmp2[SHA1_DIGEST_LENGTH];
  uint32_t x;

  if (SHA1_DIGEST_LENGTH != DRIZZLE_MAX_SCRAMBLE_SIZE)
  {
    drizzle_set_error(con->drizzle, "_pack_scramble_hash",
                      "SHA1 hash size mismatch:%u:%u", SHA1_DIGEST_LENGTH,
                      DRIZZLE_MAX_SCRAMBLE_SIZE);
    return DRIZZLE_RETURN_INTERNAL_ERROR;
  }

  if (con->scramble == NULL)
  {
    drizzle_set_error(con->drizzle, "_pack_scramble_hash",
                      "no scramble buffer");
    return DRIZZLE_RETURN_NO_SCRAMBLE;
  }

  /* First hash the password. */
  SHA1Init(&ctx);
  SHA1Update(&ctx, (uint8_t *)(con->password), strlen(con->password));
  SHA1Final(hash_tmp1, &ctx);

  /* Second, hash the password hash. */
  SHA1Init(&ctx);
  SHA1Update(&ctx, hash_tmp1, SHA1_DIGEST_LENGTH);
  SHA1Final(hash_tmp2, &ctx);

  /* Third, hash the scramble and the double password hash. */
  SHA1Init(&ctx);
  SHA1Update(&ctx, con->scramble, SHA1_DIGEST_LENGTH);
  SHA1Update(&ctx, hash_tmp2, SHA1_DIGEST_LENGTH);
  SHA1Final(buffer, &ctx);

  /* Fourth, xor the last hash against the first password hash. */
  for (x= 0; x < SHA1_DIGEST_LENGTH; x++)
    buffer[x]= buffer[x] ^ hash_tmp1[x];

  return DRIZZLE_RETURN_OK;
}

1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	1	/*
	2	* Drizzle Client & Protocol Library
	3	*
	4	* Copyright (C) 2008 Eric Day (eday@oddments.org)
	5	* All rights reserved.
	6	*
	7	* Use and distribution licensed under the BSD license. See
	8	* the COPYING file in this directory for full text.
	9	*/
	10
	11	/**
	12	* @file
	13	* @brief Packing definitions
	14	*/
	15
	16	#include "common.h"
	17
	18	/*
	19	* Private declarations
	20	*/
	21
	22	/**
	23	* @addtogroup drizzle_pack_private Private Packing Functions
	24	* @ingroup drizzle_pack
	25	* @{
	26	*/
	27
	28	/**
	29	* Compute hash from password and scramble.
	30	*/
	31	static drizzle_return_t _pack_scramble_hash(drizzle_con_st *con,
	32	uint8_t *buffer);
	33
	34	/** @} */
	35
	36	/*
	37	* Public definitions
	38	*/
	39
	40	uint8_t drizzle_pack_length(uint64_t number, uint8_t ptr)
	41	{
	42	if (number < 251)
	43	{
	44	ptr[0]= (uint8_t)number;
	45	ptr++;
	46	}
	47	else if (number < 65536)
	48	{
	49	ptr[0]= 252;
	50	ptr++;
	51	drizzle_set_byte2(ptr, number);
	52	ptr+= 2;
	53	}
	54	else if (number < 16777216)
	55	{
	56	ptr[0]= 253;
	57	ptr++;
	58	drizzle_set_byte3(ptr, number);
	59	ptr+= 3;
	60	}
	61	else
	62	{
	63	ptr[0]= 254;
	64	ptr++;
65	drizzle_set_byte8(ptr, number);
66	ptr+= 8;
67	}
68
69	return ptr;
70	}
71
72	uint64_t drizzle_unpack_length(drizzle_con_st con, drizzle_return_t ret_ptr)
73	{
74	uint64_t length;
75	uint8_t bytes;
76
77	if (con->buffer_ptr[0] < 251)
78	{
79	length= (uint64_t)(con->buffer_ptr[0]);
80	bytes= 1;
81	}
82	else if (con->buffer_ptr[0] == 251)
83	{
84	con->buffer_ptr++;
85	con->buffer_size--;
86	con->packet_size--;
87
88	*ret_ptr= DRIZZLE_RETURN_NULL_SIZE;
89	return 0;
90	}
91	else if (con->buffer_ptr[0] == 252 && con->buffer_size > 2)
92	{
93	length= drizzle_get_byte2(con->buffer_ptr + 1);
94	bytes= 3;
95	}
96	else if (con->buffer_ptr[0] == 253 && con->buffer_size > 3)
97	{
98	length= drizzle_get_byte3(con->buffer_ptr + 1);
99	bytes= 4;
100	}
101	else if (con->buffer_size > 8)
102	{
103	length= drizzle_get_byte8(con->buffer_ptr + 1);
104	bytes= 9;
105	}
106	else
107	{
108	*ret_ptr= DRIZZLE_RETURN_IO_WAIT;
109	return 0;
110	}
111
112	con->buffer_ptr+= bytes;
113	con->buffer_size-= bytes;
114	con->packet_size-= bytes;
115
116	*ret_ptr= DRIZZLE_RETURN_OK;
117	return length;
118	}
119
120	uint8_t drizzle_pack_string(char string, uint8_t *ptr)
121	{
122	uint64_t size= strlen(string);
123
124	ptr= drizzle_pack_length(size, ptr);
125	if (size > 0)
126	{
127	memcpy(ptr, string, (size_t)size);
128	ptr+= size;
129	}
130
131	return ptr;
132	}
133
134	drizzle_return_t drizzle_unpack_string(drizzle_con_st con, char buffer,
135	uint64_t max_length)
136	{
137	drizzle_return_t ret= DRIZZLE_RETURN_OK;
138	uint64_t length;
139
140	length= drizzle_unpack_length(con, &ret);
141	if (ret != DRIZZLE_RETURN_OK)
142	{
143	if (ret == DRIZZLE_RETURN_NULL_SIZE)
144	{
145	drizzle_set_error(con->drizzle, "drizzle_unpack_string",
146	"unexpected NULL length");
147	}
148
149	return ret;
150	}
151
152	if (length < max_length)
153	{
154	if (length > 0)
155	memcpy(buffer, con->buffer_ptr, (size_t)length);
156
157	buffer[length]= 0;
158	}
159	else
160	{
161	memcpy(buffer, con->buffer_ptr, (size_t)(max_length - 1));
162	buffer[max_length - 1]= 0;
163	}
164
165	con->buffer_ptr+= length;
166	con->buffer_size-= (size_t)length;
167	con->packet_size-= (size_t)length;
168
169	return DRIZZLE_RETURN_OK;
170	}
171
172	uint8_t drizzle_pack_auth(drizzle_con_st con, uint8_t *ptr,
173	drizzle_return_t *ret_ptr)
174	{
175	if (con->user[0] != 0)
176	{
177	memcpy(ptr, con->user, strlen(con->user));
178	ptr+= strlen(con->user);
179	}
180
181	ptr[0]= 0;
182	ptr++;
183
184	if (con->options & DRIZZLE_CON_RAW_SCRAMBLE && con->scramble != NULL)
185	{
186	ptr[0]= DRIZZLE_MAX_SCRAMBLE_SIZE;
187	ptr++;
188
189	memcpy(ptr, con->scramble, DRIZZLE_MAX_SCRAMBLE_SIZE);
190	ptr+= DRIZZLE_MAX_SCRAMBLE_SIZE;
191	}
192	else if (con->password[0] == 0)
193	{
194	ptr[0]= 0;
195	ptr++;
196	con->packet_size-= DRIZZLE_MAX_SCRAMBLE_SIZE;
197	}
198	else
199	{
200	ptr[0]= DRIZZLE_MAX_SCRAMBLE_SIZE;
201	ptr++;
202
203	if (con->options & DRIZZLE_CON_MYSQL)
204	{
205	*ret_ptr= _pack_scramble_hash(con, ptr);
206	if (*ret_ptr != DRIZZLE_RETURN_OK)
207	return ptr;
208	}
209	else
210	snprintf((char *)ptr, DRIZZLE_MAX_SCRAMBLE_SIZE, "%s", con->password);
211
212	ptr+= DRIZZLE_MAX_SCRAMBLE_SIZE;
213	}
214
215	if (con->db[0] != 0)
216	{
217	memcpy(ptr, con->db, strlen(con->db));
218	ptr+= strlen(con->db);
219	}
220
221	ptr[0]= 0;
222	ptr++;
223
224	*ret_ptr= DRIZZLE_RETURN_OK;
225	return ptr;
226	}
227
228	/*
229	* Private definitions
230	*/
231
232	static drizzle_return_t _pack_scramble_hash(drizzle_con_st *con,
233	uint8_t *buffer)
234	{
235	SHA1_CTX ctx;
236	uint8_t hash_tmp1[SHA1_DIGEST_LENGTH];
237	uint8_t hash_tmp2[SHA1_DIGEST_LENGTH];
238	uint32_t x;
239
240	if (SHA1_DIGEST_LENGTH != DRIZZLE_MAX_SCRAMBLE_SIZE)
241	{
242	drizzle_set_error(con->drizzle, "_pack_scramble_hash",
243	"SHA1 hash size mismatch:%u:%u", SHA1_DIGEST_LENGTH,
244	DRIZZLE_MAX_SCRAMBLE_SIZE);
245	return DRIZZLE_RETURN_INTERNAL_ERROR;
246	}
247
248	if (con->scramble == NULL)
249	{
250	drizzle_set_error(con->drizzle, "_pack_scramble_hash",
251	"no scramble buffer");
252	return DRIZZLE_RETURN_NO_SCRAMBLE;
253	}
254
255	/* First hash the password. */
256	SHA1Init(&ctx);
257	SHA1Update(&ctx, (uint8_t *)(con->password), strlen(con->password));
258	SHA1Final(hash_tmp1, &ctx);
259
260	/* Second, hash the password hash. */
261	SHA1Init(&ctx);
262	SHA1Update(&ctx, hash_tmp1, SHA1_DIGEST_LENGTH);
263	SHA1Final(hash_tmp2, &ctx);
264
265	/* Third, hash the scramble and the double password hash. */
266	SHA1Init(&ctx);
267	SHA1Update(&ctx, con->scramble, SHA1_DIGEST_LENGTH);
268	SHA1Update(&ctx, hash_tmp2, SHA1_DIGEST_LENGTH);
269	SHA1Final(buffer, &ctx);
270
271	/* Fourth, xor the last hash against the first password hash. */
272	for (x= 0; x < SHA1_DIGEST_LENGTH; x++)
273	buffer[x]= buffer[x] ^ hash_tmp1[x];
274
275	return DRIZZLE_RETURN_OK;
276	}