Exemple #1
0
void *test_list(void *param){

	thlist_data *d = (thlist_data *)param;
	int j,len=0,found=0;
	*(d->progress)=0;
	
	for(j=0;j<d->num;j++){
		
		*(d->progress)= *(d->progress)+1;
		len = strlen(d->list[j]);
		found = open_key(d->list[j], len, &(d->header), d->iv_mode, 
				d->chain_mode, d->crypt_disk, 
				d->fast_check, d->keyslot, d->pbk_hash);

		if(found){

			/* entering mutex section */
			pthread_mutex_lock(&condition_mutex);
			pthread_cond_signal(&condition_cond);
			
			memset(d->win_pwd,0,d->max_l);
			sprintf(d->win_pwd,"%s",d->list[j]);
			
			/* exiting mutex section */
			pthread_mutex_unlock(&condition_mutex);
		}
	}
	
	for(j=0;j<d->num;j++){
		free(d->list[j]);
	}
	pthread_exit(NULL);
}
Exemple #2
0
void lemur::file::Keyfile::open( const char* filename, int cacheSize, bool readOnly) {
  _buildHandle( cacheSize );
  
  int error = open_key( _handle, const_cast<char*>(filename), 
                        _handleSize, readOnly ? 1 : 0);

  if( error )
    LEMUR_THROW(LEMUR_KEYFILE_IO_ERROR, "Unable to open '" + filename + "'");
}
Exemple #3
0
/*
 * Enumerates all of the values at the supplied HKEY.
 *
 * TLVs:
 *
 * req: TLV_TYPE_ROOT_KEY   - The root key
 * req: TLV_TYPE_BASE_KEY   - The base key
 * opt: TLV_TYPE_PERMISSION - Permissions with which to open the key
 */
DWORD request_registry_enum_value_direct(Remote *remote, Packet *packet)
{
	HKEY rootkey, hkey = NULL;

	open_key(packet, &rootkey, &hkey);
	enum_value(remote, packet, hkey);
	if (hkey)
		RegCloseKey(hkey);

	return ERROR_SUCCESS;
}
Exemple #4
0
static int net_registry_enumerate(struct net_context *c, int argc,
				  const char **argv)
{
	WERROR werr;
	struct registry_key *key = NULL;
	TALLOC_CTX *ctx = talloc_stackframe();
	char *subkey_name;
	NTTIME modtime;
	uint32_t count;
	char *valname = NULL;
	struct registry_value *valvalue = NULL;
	int ret = -1;

	if (argc != 1 || c->display_usage) {
		d_printf("Usage:    net registry enumerate <path>\n");
		d_printf("Example:  net registry enumerate "
			 "'HKLM\\Software\\Samba'\n");
		goto done;
	}

	werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
	if (!W_ERROR_IS_OK(werr)) {
		d_fprintf(stderr, "open_key failed: %s\n", win_errstr(werr));
		goto done;
	}

	for (count = 0;
	     werr = reg_enumkey(ctx, key, count, &subkey_name, &modtime),
	     W_ERROR_IS_OK(werr);
	     count++)
	{
		print_registry_key(subkey_name, &modtime);
	}
	if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
		goto done;
	}

	for (count = 0;
	     werr = reg_enumvalue(ctx, key, count, &valname, &valvalue),
	     W_ERROR_IS_OK(werr);
	     count++)
	{
		print_registry_value_with_name(valname, valvalue);
	}
	if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
		goto done;
	}

	ret = 0;
done:
	TALLOC_FREE(ctx);
	return ret;
}
main(int argc,char *argv[])
{
	int op;
	op = atoi(argv[3]);
	printf("op is %d\n",op);

	spi_modules_init(argv[1]);
	if(!strcmp(argv[2],"-r"))
		{
		}
		else if(!strcmp(argv[2],"-g"))
		{
			printf("the voltage is %d\n",read_voltage());
		}
		else if(!strcmp(argv[2],"-p"))
		{

		}
		else if(!strcmp(argv[2],"-c"))
		{

			poweroff_now();
		}
		else if(!strcmp(argv[2],"-l1"))
		{
			operation_lm1(op);
		}
		else if(!strcmp(argv[2],"-o"))
		{
			out_12(op);
		}
		else if(!strcmp(argv[2],"-l2"))
		{
			operation_lm2(op);
		}
		else if(!strcmp(argv[2],"-l3"))
		{
			operation_lm2(op);
		}
		else if(!strcmp(argv[2],"-b"))
		{
			printf("operation_bark\n");
			operation_backlight(op);
		}else if(!strcmp(argv[2],"-k"))
		{
			open_key();
		}else if(!strcmp(argv[2],"-re"))
		{
			restart_system();
		}

}
Exemple #6
0
result_t rmdir_path_action(cli_t *context, const char * name_)
  {
  result_t result;
  memid_t key;

  if(failed(result = open_key(get_context(context), name_, false, &key)) ||
      failed(result = reg_delete_key(key)))
    {
    stream_puts(context->cfg.console_err, "Error when deleting key\r\n");
    return result;
    }
  return s_ok;
  }
Exemple #7
0
void *th_force(void *param){

	thforce_data *d = (thforce_data *)param;
	char *guess;
	int i,n,k,found;

	if((guess = calloc(d->len+1,sizeof(char)))==NULL){
		errprint("malloc error!\n");
		return 0;
	}

	*(d->progress)=0;
	found=0;

	for (i=0;i<d->comb;i++) {
		n = i;
		guess[0]=d->set[d->start + (i % d->num)];
		n/= d->num;
		for (k=1; k<d->len; k++){
			guess[k] = d->set[n % d->set_len]; 
			n /= d->set_len;
		}

		
		found = open_key(guess, d->len, &(d->header), d->iv_mode, 
				d->chain_mode, d->crypt_disk,
				d->fast_check, d->keyslot, d->pbk_hash);
		
		*(d->progress)=*(d->progress) + 1;

		if(found){

			/* entering mutex section */
			pthread_mutex_lock(&condition_mutex);
			pthread_cond_signal(&condition_cond);

			memset(d->win_pwd,0,d->len);
			sprintf(d->win_pwd,"%s",guess);

			/* exiting mutex section */
			pthread_mutex_unlock(&condition_mutex);
			goto end;
		}
	}

end:
	free(guess);
	pthread_exit(NULL);
}
Exemple #8
0
static int open_jpsystem_init(void)
{
	int i;
	int voltage = 0;
	struct timespec rem = { 0, 5000000};
	for (i = 0; i < 4; i++) {
		voltage = read_voltage();
		nanosleep(&rem, &rem);
		DEBUG_OUT(DEBUG_GZQ, "read voltage = %d\n", voltage);
	}
	
	operation_lm2(1);
	operation_12v(1);

	open_key();
	return 0;
}
Exemple #9
0
static int net_registry_getvaluesraw(struct net_context *c, int argc,
				     const char **argv)
{
	WERROR werr;
	int ret = -1;
	struct registry_key *key = NULL;
	TALLOC_CTX *ctx = talloc_stackframe();
	uint32_t idx;

	if (argc != 1 || c->display_usage) {
		d_fprintf(stderr, "usage: net rpc registry getvaluesraw "
			  "<key>\n");
		goto done;
	}

	werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
	if (!W_ERROR_IS_OK(werr)) {
		d_fprintf(stderr, "open_key failed: %s\n", win_errstr(werr));
		goto done;
	}

	idx = 0;
	while (true) {
		struct registry_value *val;

		werr = reg_enumvalue(talloc_tos(), key, idx, NULL, &val);

		if (W_ERROR_EQUAL(werr, WERR_NO_MORE_ITEMS)) {
			ret = 0;
			break;
		}
		if (!W_ERROR_IS_OK(werr)) {
			break;
		}
		print_registry_value(val, true);
		TALLOC_FREE(val);
		idx += 1;
	}
done:
	TALLOC_FREE(ctx);
	return ret;
}
Exemple #10
0
/*
 * Opens a registry key and returns the associated HKEY to the caller if the
 * operation succeeds.
 *
 * TLVs:
 *
 * req: TLV_TYPE_ROOT_KEY   - The root key
 * req: TLV_TYPE_BASE_KEY   - The base key
 * opt: TLV_TYPE_PERMISSION - Permissions with which to open the key
 */
DWORD request_registry_open_key(Remote *remote, Packet *packet)
{
	Packet *response = packet_create_response(packet);
	DWORD result;
	HKEY rootKey, resKey;

	result = open_key(packet, &rootKey, &resKey);

	// Add the HKEY if we succeeded, but always return a result
	if (result == ERROR_SUCCESS)
	{
		packet_add_tlv_qword(response, TLV_TYPE_HKEY, (QWORD)resKey);
	}

	packet_add_tlv_uint(response, TLV_TYPE_RESULT, result);

	packet_transmit(remote, response, NULL);

	return ERROR_SUCCESS;
}
Exemple #11
0
// sign a hash of input using private key
void sign (void)
{
  char *p;
  
  // initialize crypto API
  if (open_crypt())
  {
    // import our private key
    if (open_key (RSA_PRIVATE_BIN))
    {
      // hash the input
      if (open_hash ())
      {
        // obtain size of signature
        CryptSignHash (hHash, AT_SIGNATURE, NULL, 0, NULL, &dwSigLen);
        pbSignature=xmalloc (dwSigLen);
        // sign the hash to obtain signature
        if (CryptSignHash (hHash, AT_SIGNATURE, NULL, 0, pbSignature, &dwSigLen))
        {
          p=sig2hex();
          if (p)
          {
            printf ("  [ signature is: %i::%s\n", lstrlen(p), p);
          }
          xfree (pbSignature);
        } else {
           xstrerror ("CryptSignHash()");
        }
        close_hash();
      } else {
        xstrerror ("open_hash()");
      }
      close_key();
    } else {
      xstrerror ("open_key()");
    }
    close_crypt();
  } else {
    xstrerror ("open_crypt()");
  }
}
Exemple #12
0
NTSTATUS NTAPI NtOpenKey(
	PHANDLE KeyHandle,
	ACCESS_MASK DesiredAccess,
	POBJECT_ATTRIBUTES ObjectAttributes )
{
	OBJECT_ATTRIBUTES oa;
	unicode_string_t us;
	NTSTATUS r;
	regkey_t *key = NULL;

	trace("%p %08lx %p\n", KeyHandle, DesiredAccess, ObjectAttributes );

	// copies the unicode string before validating object attributes struct
	r = copy_from_user( &oa, ObjectAttributes, sizeof oa );
	if (r < STATUS_SUCCESS)
		return r;

	r = us.copy_from_user( oa.ObjectName );
	if (r < STATUS_SUCCESS)
		return r;
	oa.ObjectName = &us;

	if (oa.Length != sizeof oa)
		return STATUS_INVALID_PARAMETER;

	trace("len %08lx root %p attr %08lx %pus\n",
			oa.Length, oa.RootDirectory, oa.Attributes, oa.ObjectName);

	r = open_key( &key, &oa );

	trace("open_key returned %08lx\n", r);

	if (r == STATUS_SUCCESS)
	{
		r = alloc_user_handle( key, DesiredAccess, KeyHandle );
		//release( event );
	}

	return r;
}
// verify a signature using public key
BOOL verify(void)
{
    BOOL bStatus = FALSE;

    // initialize crypto API
    if (open_crypt()) {
        // import public key
        if (open_key(DSA_PUBLIC_BIN)) {
            // hash the input
            if (open_hash()) {
                // convert signature to binary
                sig2bin();

                if (pbSignature != NULL) {
                    // verify signature
                    bStatus = CryptVerifySignature(hHash, pbSignature,
                                                   dwSigLen, hKey, NULL, 0);
                    printf("  [ signature is %s\n",
                           bStatus ? "valid" : "invalid");
                    xfree(pbSignature);
                }

                close_hash();
            } else {
                printf("open_hash()");
            }

            close_key();
        } else {
            printf("open_key()");
        }

        close_crypt();
    } else {
        printf("open_crypt()");
    }

    return bStatus;
}
Exemple #14
0
result_t cd_path_action(cli_t *context, const char * name_)
  {
  // open a sub-key
  result_t result;
  memid_t memid = 0;
  if(failed(result = open_key(get_context(context), name_, false, &memid)))
    {
    stream_puts(context->cfg.console_err, "Error when creating key\r\n");
    return result;
    }

  // update the submode
  const char * dirname = get_full_path(memid);

  char prompt[MAX_PROMPT_LENGTH];
  snprintf(prompt, MAX_PROMPT_LENGTH, "%s %s ", node_name, dirname);
  neutron_free((void *)dirname);

  strncpy(context->prompt[context->root_level], prompt, MAX_PROMPT_LENGTH);
  context->current[context->root_level] = memid;

  return s_ok;
  }
Exemple #15
0
static int net_registry_getvalue_internal(struct net_context *c, int argc,
					  const char **argv, bool raw)
{
	WERROR werr;
	int ret = -1;
	struct registry_key *key = NULL;
	struct registry_value *value = NULL;
	TALLOC_CTX *ctx = talloc_stackframe();

	if (argc != 2 || c->display_usage) {
		d_fprintf(stderr, "%s\n%s",
			  _("Usage:"),
			  _("net registry getvalue <key> <valuename>\n"));
		goto done;
	}

	werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
	if (!W_ERROR_IS_OK(werr)) {
		d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
		goto done;
	}

	werr = reg_queryvalue(ctx, key, argv[1], &value);
	if (!W_ERROR_IS_OK(werr)) {
		d_fprintf(stderr, _("reg_queryvalue failed: %s\n"),
			  win_errstr(werr));
		goto done;
	}

	print_registry_value(value, raw);

	ret = 0;

done:
	TALLOC_FREE(ctx);
	return ret;
}