Beispiel #1
0
void Poly1305::add_data(const byte input[], size_t length)
   {
   BOTAN_ASSERT_EQUAL(m_poly.size(), 8, "Initialized");

   if(m_buf_pos)
      {
      buffer_insert(m_buf, m_buf_pos, input, length);

      if(m_buf_pos + length >= m_buf.size())
         {
         poly1305_blocks(m_poly, m_buf.data(), 1);
         input += (m_buf.size() - m_buf_pos);
         length -= (m_buf.size() - m_buf_pos);
         m_buf_pos = 0;
         }
      }

   const size_t full_blocks = length / m_buf.size();
   const size_t remaining   = length % m_buf.size();

   if(full_blocks)
      poly1305_blocks(m_poly, input, full_blocks);

   buffer_insert(m_buf, m_buf_pos, input + full_blocks * m_buf.size(), remaining);
   m_buf_pos += remaining;
   }
Beispiel #2
0
/*
* PSSR Encode Operation
*/
secure_vector<byte> PSSR::encoding_of(const secure_vector<byte>& msg,
                                      size_t output_bits,
                                      RandomNumberGenerator& rng)
{
    const size_t HASH_SIZE = m_hash->output_length();

    if(msg.size() != HASH_SIZE)
        throw Encoding_Error("PSSR::encoding_of: Bad input length");
    if(output_bits < 8*HASH_SIZE + 8*m_SALT_SIZE + 9)
        throw Encoding_Error("PSSR::encoding_of: Output length is too small");

    const size_t output_length = (output_bits + 7) / 8;

    secure_vector<byte> salt = rng.random_vec(m_SALT_SIZE);

    for(size_t j = 0; j != 8; ++j)
        m_hash->update(0);
    m_hash->update(msg);
    m_hash->update(salt);
    secure_vector<byte> H = m_hash->final();

    secure_vector<byte> EM(output_length);

    EM[output_length - HASH_SIZE - m_SALT_SIZE - 2] = 0x01;
    buffer_insert(EM, output_length - 1 - HASH_SIZE - m_SALT_SIZE, salt);
    mgf1_mask(*m_hash, H.data(), HASH_SIZE, EM.data(), output_length - HASH_SIZE - 1);
    EM[0] &= 0xFF >> (8 * ((output_bits + 7) / 8) - output_bits);
    buffer_insert(EM, output_length - 1 - HASH_SIZE, H);
    EM[output_length-1] = 0xBC;

    return EM;
}
Beispiel #3
0
/*
* OAEP Pad Operation
*/
secure_vector<byte> OAEP::pad(const byte in[], size_t in_length,
                             size_t key_length,
                             RandomNumberGenerator& rng) const
   {
   key_length /= 8;

   if(key_length < in_length + 2*m_Phash.size() + 1)
      throw Invalid_Argument("OAEP: Input is too large");

   secure_vector<byte> out(key_length);

   rng.randomize(out.data(), m_Phash.size());

   buffer_insert(out, m_Phash.size(), m_Phash.data(), m_Phash.size());
   out[out.size() - in_length - 1] = 0x01;
   buffer_insert(out, out.size() - in_length, in, in_length);

   mgf1_mask(*m_hash,
             out.data(), m_Phash.size(),
             &out[m_Phash.size()], out.size() - m_Phash.size());

   mgf1_mask(*m_hash,
             &out[m_Phash.size()], out.size() - m_Phash.size(),
             out.data(), m_Phash.size());

   return out;
   }
Beispiel #4
0
/*
* Update the hash
*/
void MDx_HashFunction::add_data(const uint8_t input[], size_t length)
   {
   m_count += length;

   if(m_position)
      {
      buffer_insert(m_buffer, m_position, input, length);

      if(m_position + length >= m_buffer.size())
         {
         compress_n(m_buffer.data(), 1);
         input += (m_buffer.size() - m_position);
         length -= (m_buffer.size() - m_position);
         m_position = 0;
         }
      }

   const size_t full_blocks = length / m_buffer.size();
   const size_t remaining   = length % m_buffer.size();

   if(full_blocks)
      compress_n(input, full_blocks);

   buffer_insert(m_buffer, m_position, input + full_blocks * m_buffer.size(), remaining);
   m_position += remaining;
   }
Beispiel #5
0
/**
* Hash additional inputs
*/
void GOST_34_11::add_data(const uint8_t input[], size_t length)
{
    m_count += length;

    if(m_position)
    {
        buffer_insert(m_buffer, m_position, input, length);

        if(m_position + length >= hash_block_size())
        {
            compress_n(m_buffer.data(), 1);
            input += (hash_block_size() - m_position);
            length -= (hash_block_size() - m_position);
            m_position = 0;
        }
    }

    const size_t full_blocks = length / hash_block_size();
    const size_t remaining   = length % hash_block_size();

    if(full_blocks)
        compress_n(input, full_blocks);

    buffer_insert(m_buffer, m_position, input + full_blocks * hash_block_size(), remaining);
    m_position += remaining;
}
Beispiel #6
0
/*
* Update the hash
*/
void Streebog::add_data(const uint8_t input[], size_t length)
   {
   const size_t block_size = m_buffer.size();

   if(m_position)
      {
      buffer_insert(m_buffer, m_position, input, length);

      if(m_position + length >= block_size)
         {
         compress(m_buffer.data());
         m_count += 512;
         input += (block_size - m_position);
         length -= (block_size - m_position);
         m_position = 0;
         }
      }

   const size_t full_blocks = length / block_size;
   const size_t remaining   = length % block_size;

   for(size_t i = 0; i != full_blocks; ++i)
      {
      compress(input + block_size * i);
      m_count += 512;
      }

   buffer_insert(m_buffer, m_position, input + full_blocks * block_size, remaining);
   m_position += remaining;
   }
Beispiel #7
0
Datei: buffer.c Projekt: erf/vis
bool buffer_insert0(Buffer *buf, size_t pos, const char *data) {
	if (pos == 0)
		return buffer_prepend0(buf, data);
	if (pos == buf->len)
		return buffer_append0(buf, data);
	return buffer_insert(buf, pos, data, strlen(data));
}
Beispiel #8
0
int string_insert(string *s, size_t pos, char *data)
{
  if (pos > string_length(s))
    return -1;

  return buffer_insert(&s->buffer, pos, data, strlen(data));
}
Beispiel #9
0
/**
 * @brief circular buffer test application
 */
 int main(int argc, char **argv)
 {
    unsigned char data = {0};
    int size = 0;

    printf("How much characteres you want to put?  ");
    scanf("%d", &size);
    for(unsigned int i = 0; i < size; ++i) {
      printf("Enter the %d value:  ",i);
      scanf("%hu", &data);

      /* put the new byte on buffer
       * NOTE! We dont need to manage our buffer
       */
      buffer_insert(&console_buffer,&data, 1);
    }

    /* prints the buffer contents */
    printf("The buffer contents are \n\r");
    while(buffer_empty(&console_buffer) == 0) {

        /* extracts byte to byte from buffer, higher sizes streams are supported
         * but this mode shows better the capabilities of circ buffer
         */
        buffer_retrieve(&console_buffer, &data, 1);
        printf("%hu",&data );
    }

    /* wait for a key */
    scanf("%hu", &data);
    return(0);

 }
Beispiel #10
0
static int luastream_insert (lua_State *L)
{
	int i, top = lua_gettop(L);
	struct writer_t W;
	lua_Stream *self = (lua_Stream *)luaL_checkudata(L, 1, LUA_STREAM);
	size_t size, pos = luaL_checkint(L, 2);
	luaL_check(self->buf, "%s (released) #1", LUA_STREAM);
	luaL_check(pos <= buffer_tell(&self->buf), "out of range #2");
	W.count = 0;
	if (pos < buffer_tell(&self->buf))
	{
		buffer_t buf = buffer_new(BUFF_SIZE);
		for (i = 3, W.pos = 0; i <= top; ++i, W.pos = buffer_tell(&buf))
			buffer_writeobject(L, &buf, i, &W);
		size = buffer_tell(&buf);
		buffer_insert(&self->buf, pos, buffer_ptr(&buf), size);
		buffer_delete(&buf);
	}
	else
	{
		for (i = 3, W.pos = pos; i <= top; ++i, W.pos = buffer_tell(&self->buf))
			buffer_writeobject(L, &self->buf, i, &W);
		size = buffer_tell(&self->buf) - pos;
	}
	lua_pushnumber(L, pos);
	lua_pushnumber(L, pos + size);
	return 2;
}
Beispiel #11
0
/*
* PSSR Decode/Verify Operation
*/
bool PSSR::verify(const secure_vector<byte>& const_coded,
                   const secure_vector<byte>& raw, size_t key_bits)
   {
   const size_t HASH_SIZE = hash->output_length();
   const size_t KEY_BYTES = (key_bits + 7) / 8;

   if(key_bits < 8*HASH_SIZE + 9)
      return false;

   if(raw.size() != HASH_SIZE)
      return false;

   if(const_coded.size() > KEY_BYTES || const_coded.size() <= 1)
      return false;

   if(const_coded[const_coded.size()-1] != 0xBC)
      return false;

   secure_vector<byte> coded = const_coded;
   if(coded.size() < KEY_BYTES)
      {
      secure_vector<byte> temp(KEY_BYTES);
      buffer_insert(temp, KEY_BYTES - coded.size(), coded);
      coded = temp;
      }

   const size_t TOP_BITS = 8 * ((key_bits + 7) / 8) - key_bits;
   if(TOP_BITS > 8 - high_bit(coded[0]))
      return false;

   byte* DB = &coded[0];
   const size_t DB_size = coded.size() - HASH_SIZE - 1;

   const byte* H = &coded[DB_size];
   const size_t H_size = HASH_SIZE;

   mgf1_mask(*hash, &H[0], H_size, &DB[0], DB_size);
   DB[0] &= 0xFF >> TOP_BITS;

   size_t salt_offset = 0;
   for(size_t j = 0; j != DB_size; ++j)
      {
      if(DB[j] == 0x01)
         { salt_offset = j + 1; break; }
      if(DB[j])
         return false;
      }
   if(salt_offset == 0)
      return false;

   for(size_t j = 0; j != 8; ++j)
      hash->update(0);
   hash->update(raw);
   hash->update(&DB[salt_offset], DB_size - salt_offset);
   secure_vector<byte> H2 = hash->final();

   return same_mem(&H[0], &H2[0], HASH_SIZE);
   }
Beispiel #12
0
void OFB::set_iv(const byte iv[], size_t iv_len)
   {
   if(!valid_iv_length(iv_len))
      throw Invalid_IV_Length(name(), iv_len);

   zeroise(m_buffer);
   buffer_insert(m_buffer, 0, iv, iv_len);

   m_cipher->encrypt(m_buffer);
   m_buf_pos = 0;
   }
Beispiel #13
0
void producer(int nconsumers)
{
  char buffer[MAXLINELEN];
  int number;

  printf("  producer: starting\n");

  while (fgets(buffer, MAXLINELEN, stdin) != NULL)
    {
      number = atoi(buffer);
      printf("producer: %d\n", number);
      buffer_insert(number);
    }

  printf("producer: read EOF, sending %d '-1' numbers\n", nconsumers);
  for (number = 0; number < nconsumers; number++)
    buffer_insert(-1);

  printf("producer: exiting\n");
}
Beispiel #14
0
bool buffer_insert_ts (Buffer* buffer, int32_t index, unsigned char* data, int32_t length) {
    assert(NULL != buffer);
    assert(NULL != buffer->mutex);

    pthread_mutex_lock(buffer->mutex);

    bool ret = buffer_insert(buffer, index, data, length);

    pthread_mutex_unlock(buffer->mutex);

    return ret;
}
Beispiel #15
0
void ppmoutput_cleanup_frame( stream_node_t *node, framebuffer_t *frame )
{
    // Either destroy the frame or insert it in the output buffer
    if( node->output == NULL )
    {
        framebuffer_destroy( frame );
        free( frame );
    }
    else
    {
        buffer_insert( node->output, frame );
    }
}
Beispiel #16
0
int main( int argc, char* argv[] )
{
	struct buffer* buf = buffer_new();

	buffer_insert_from_array( buf, 0, "Hello World!", 0, 12 );
	printf( "%s\n", buffer_pointer( buf ) );

	buffer_insert( buf, buffer_length( buf ), '\n' );

	buffer_insert_from_array( buf, buffer_length( buf ), "Hello World!", 0, 12 );
	printf( "%s\n", buffer_pointer( buf ) );

	buffer_del( &buf );

	return 0;
}
Beispiel #17
0
Datei: file.c Projekt: 8l/aoeui
void text_dirty(struct text *text)
{
	if (text->path && !text->dirties && text->flags & TEXT_RDONLY)
		message("%s: read-only, %s",
			path_format(text->path),
			make_writable ? "will be made writable"
				      : "changes won't be saved here");
	text->dirties++;
	if (!text->buffer) {
		text->buffer = buffer_create(text->fd >= 0 ? text->path : NULL);
		if (text->clean)
			buffer_insert(text->buffer, text->clean, 0,
				      text->clean_bytes);
		grab_mtime(text);
	}
}
Beispiel #18
0
/*
* Convert some data into hex format
*/
void Hex_Encoder::write(const byte input[], size_t length)
   {
   buffer_insert(in, position, input, length);
   if(position + length >= in.size())
      {
      encode_and_send(in.data(), in.size());
      input += (in.size() - position);
      length -= (in.size() - position);
      while(length >= in.size())
         {
         encode_and_send(input, in.size());
         input += in.size();
         length -= in.size();
         }
      copy_mem(in.data(), input, length);
      position = 0;
      }
   position += length;
   }
Beispiel #19
0
void fill_buffer( buffer_t *buffer )
{
    int32 i;
    framebuffer_t *frame;

    printf( "Filling start thread's input buffer...\n" );
    for( i = 0; i < buffer->size; i++ )
    {
        // Allocate a new frame 
        frame = (framebuffer_t*)malloc( sizeof(framebuffer_t) );
        if( frame != NULL )
        {
            framebuffer_create( frame, INPUT_WIDTH, INPUT_HEIGHT );
        }

        // Insert the frame into the buffer
        buffer_insert( buffer, frame );
    }
}
Beispiel #20
0
/*
* Convert some data into Base64
*/
void Base64_Encoder::write(const byte input[], size_t length)
   {
   buffer_insert(m_in, m_position, input, length);
   if(m_position + length >= m_in.size())
      {
      encode_and_send(m_in.data(), m_in.size());
      input += (m_in.size() - m_position);
      length -= (m_in.size() - m_position);
      while(length >= m_in.size())
         {
         encode_and_send(input, m_in.size());
         input += m_in.size();
         length -= m_in.size();
         }
      copy_mem(m_in.data(), input, length);
      m_position = 0;
      }
   m_position += length;
   }
Beispiel #21
0
string *string_substr(string *s, size_t pos, size_t len)
{
  string *result;
  size_t n, l = string_length(s);

  if (pos > l)
    return NULL;

  result = malloc(sizeof *result);
  if (!result)
    return NULL;

  n = l - pos < len ? l - pos : len;

  buffer_init(&result->buffer);
  buffer_reserve(&result->buffer, n + 1);
  buffer_insert(&result->buffer, 0, string_data(s) + pos, n);
  string_data(result)[n] = 0;

  return result;
}
Beispiel #22
0
/*
* PKCS1 Pad Operation
*/
secure_vector<byte> EME_PKCS1v15::pad(const byte in[], size_t inlen,
                                     size_t olen,
                                     RandomNumberGenerator& rng) const
   {
   olen /= 8;

   if(olen < 10)
      throw Encoding_Error("PKCS1: Output space too small");
   if(inlen > olen - 10)
      throw Encoding_Error("PKCS1: Input is too large");

   secure_vector<byte> out(olen);

   out[0] = 0x02;
   for(size_t j = 1; j != olen - inlen - 1; ++j)
      while(out[j] == 0)
         out[j] = rng.next_byte();
   buffer_insert(out, olen - inlen, in, inlen);

   return out;
   }
Beispiel #23
0
void* tgainput_thread( void *arg )
{
    Hint res;
    stream_node_t *node;
    framebuffer_t image;
    framebuffer_t *frame;

    // Get the argument to the thread
    node = (stream_node_t*)arg;

    // Check that the node was setup correctly
    tgainput_check_buffers( node );

    // Read the image in
    res = framebuffer_tgain( &image, "image.tga" );
    if( res != 0 )
    {
        perror( "cannot read input image" );
        exit(1);
    }

    // Run the input thread
    while( 1 )
    {
        // Get the next video frame
        frame = tgainput_next_frame( node, &image );

        // Determine if we should halt the processing
        if( frame == NULL ) break;

        // Copy the video into the output frame
        framebuffer_copy( frame, &image );

        // Insert the image to the output buffer
        buffer_insert( node->output, frame );
    }

    // Finish running the thread
    return NULL;
}
Beispiel #24
0
/*
* Update an CMAC Calculation
*/
void CMAC::add_data(const uint8_t input[], size_t length)
   {
   const size_t bs = output_length();

   buffer_insert(m_buffer, m_position, input, length);
   if(m_position + length > bs)
      {
      xor_buf(m_state, m_buffer, bs);
      m_cipher->encrypt(m_state);
      input += (bs - m_position);
      length -= (bs - m_position);
      while(length > bs)
         {
         xor_buf(m_state, input, bs);
         m_cipher->encrypt(m_state);
         input += bs;
         length -= bs;
         }
      copy_mem(m_buffer.data(), input, length);
      m_position = 0;
      }
   m_position += length;
   }
Beispiel #25
0
static int luastream_copy (lua_State *L)
{
	lua_Stream *self, *other;
	int index = 1;
	size_t pos, total, size;
	self = (lua_Stream *)luaL_checkudata(L, index, LUA_STREAM);
	luaL_check(self->buf, "%s (released) #1", LUA_STREAM);
	if (lua_isnumber(L, index))
		pos = lua_tonumber(L, ++index);
	else
		pos = buffer_tell(&self->buf);
	other = (lua_Stream *)luaL_checkudata(L, ++index, LUA_STREAM);
	luaL_check(pos <= buffer_tell(&self->buf), "out of range #2");
	luaL_check(other->buf, "%s (released) #%d", LUA_STREAM, index);
	total = buffer_tell(&other->buf);
	size = luaL_optint(L, ++index, total > other->pos ? total - other->pos : 0);
	luaL_check(other->pos + size <= total, "size overflow #%d", index);
	if (size)
		buffer_insert(&self->buf, pos, buffer_at(&other->buf, other->pos), size);
	lua_pushnumber(L, pos);
	lua_pushnumber(L, pos + size);
	return 2;
}
Beispiel #26
0
static void reactor_stream_read(reactor_stream *stream)
{
  char buffer[REACTOR_STREAM_BLOCK_SIZE];
  reactor_stream_data data;
  ssize_t n;

  n = read(reactor_desc_fd(&stream->desc), buffer, sizeof buffer);
  if (n <= 0)
    {
      if (n == 0)
        reactor_user_dispatch(&stream->user, REACTOR_STREAM_CLOSE, stream);
      else if (errno != EAGAIN)
        reactor_user_dispatch(&stream->user, REACTOR_STREAM_ERROR, stream);
      return;
    }

  reactor_stream_hold(stream);
  if (buffer_size(&stream->read) == 0)
    {
      data = (reactor_stream_data) {.base = buffer, .size = n};
      reactor_user_dispatch(&stream->user, REACTOR_STREAM_READ, &data);
      if (data.size)
        buffer_insert(&stream->read, buffer_size(&stream->read), data.base, data.size);
    }
Beispiel #27
0
Datei: file.c Projekt: 8l/aoeui
static ssize_t old_fashioned_read(struct text *text)
{
	char *raw;
	ssize_t got, total = 0;
	size_t max;
#define CHUNK 1024

	do {
		buffer_insert(text->buffer, NULL, total, CHUNK);
		max = buffer_raw(text->buffer, &raw, total, CHUNK);
		errno = 0;
		got = read(text->fd, raw, max);
		if (got < 0) {
			message("%s: can't read",
				path_format(text->path));
			buffer_delete(text->buffer, 0, total + CHUNK);
			return -1;
		}
		buffer_delete(text->buffer, total + got, CHUNK - got);
		total += got;
	} while (got);

	return total;
}
Beispiel #28
0
int string_append(string *s, char *data)
{
  return buffer_insert(&s->buffer, string_length(s), data, strlen(data));  
}
Beispiel #29
0
int string_prepend(string *s, char *data)
{
  return buffer_insert(&s->buffer, 0, data, strlen(data));
}
Beispiel #30
0
void string_clear(string *s)
{
  buffer_clear(&s->buffer);
  buffer_insert(&s->buffer, 0, "", 1);
}