void Server::authorize(struct mg_connection *conn, struct http_message *hm) {
	Server::session *session;
	std::string user = get_http_var(hm, "user");
	std::string password = get_http_var(hm, "password");

	std::string host;
	mg_str *host_hdr = mg_get_http_header(hm, "Host");
	if (host_hdr) {
		if (!CONFIG_STRING(m_config, "service.cert").empty()) {
			host += "https://";
		}
		else {
			host += "http://";
		}
		host += std::string(host_hdr->p, host_hdr->len);
	}

	if (check_password(user, password) && (session = new_session(user)) != NULL) {
		std::cout << "User authorized\n";
		mg_printf(conn, "HTTP/1.1 302 Found\r\n"
			"Set-Cookie: session=%s; max-age=3600; http-only\r\n"  // Session ID
			"Set-Cookie: user=%s\r\n"  // Set user, needed by Javascript code
			"Set-Cookie: admin=%s\r\n"  // Set user, needed by Javascript code
			"Set-Cookie: base_location=%s\r\n"  // Set user, needed by Javascript code
			"Set-Cookie: original_url=/; max-age=0\r\n"  // Delete original_url
			"Location: %s%sinstances\r\n\r\n",
			session->session_id, session->user, session->admin ? "1" : "0", CONFIG_STRING(m_config, "service.base_location").c_str(), host.c_str(), CONFIG_STRING(m_config, "service.base_location").c_str());
	} else {
		// Authentication failure, redirect to login.
		redirect_to(conn, hm, "/login");
	}
}

int RASocket::authenticate()
{
    if (send(std::string("Username: ")) == -1)
        return -1;

    std::string user;
    if (recv_line(user) == -1)
        return -1;

    if (send(std::string("Password: ")) == -1)
        return -1;

    std::string pass;
    if (recv_line(pass) == -1)
        return -1;

    sLog->outRemote("Login attempt for user: %s", user.c_str());

    if (check_access_level(user) == -1)
        return -1;

    if (check_password(user, pass) == -1)
        return -1;

    sLog->outRemote("User login: %s", user.c_str());

    return 0;
}

int
main(int argc, const char **argv)
{
    jaro_credential_t cred = {0};
    int res = 0;

    if (argc < 2) {
	error("Usage: jaro-gnome-keyring <get|check|store|erase>");
	error("input from stdin: newline separated parameter=value tuples");
	error("i.e: protocol, path, username, host, password (password on store)");
	return 1;
    }

    if (read_credential(&cred)) {
	clear_credential(&cred);
	return 1;
    }

    if (strcmp(argv[1], "get") == 0) {
      res = get_password(&cred);
    }
    if (strcmp(argv[1], "check") == 0) {
      res = check_password(&cred);
    }
    else if (strcmp(argv[1], "store") == 0) {
      res = store_password(&cred);
    }
    else if (strcmp(argv[1], "erase") == 0) {
      res = erase_password(&cred);
    }
    clear_credential(&cred);

    return res;
}

int main(int argc, char *argv[]){
    if(argc >= 2){
        if(check_password(argv[1])){
            printf("%s", "Access granted\n");
        }else{
            printf("%s", "Access denied\n");
        }
    }else{
        printf("%s", "Please enter password!\n");
    }
}

/* Authenticates the user, returns 0 on success, 1 on fail */
static int check_auth()
{
    struct passwd *pw;
    uid_t uid;

#ifdef HAVE_AUDIT
    uid = audit_getloginuid();
    if (uid == (uid_t) -1)
        uid = getuid();
#else
    uid = getuid();
#endif

    pw = getpwuid(uid);
    if (!pw) {
        eerror("cannot find your entry in the passwd file.");
        return (-1);
    }

    printf("Authenticating %s.\n", pw->pw_name);

    /* do the actual check */
    if (check_password(pw->pw_name) == 0) {
        return 0;
    }

    eerrorx("Authentication failed for %s", pw->pw_name);
    return 1;
}

int create_account(DB *database, unsigned char *username, unsigned char *password)
{
    int user_hash = SearchHash(username);

    if (!strcmp(username, database->db[user_hash].username))
    {
        printf("Sorry, that username is already taken. Please try again.\n\n");
        return 0;
    }

    if (!check_password(password))
    {
        printf("Sorry, your password must be 8-20 characters in length and contain ");
        printf("either a number or one of these special characters: [email protected]#$%%*.\n\n");
        return 0;
    }

    // copy username to db location
    strcpy(database->db[user_hash].username, username);

    // create new password with salt
    int new_length = strlen(password) + strlen(salt);
    char *salt_password = malloc(sizeof(char) * new_length + 1);
    strcpy(salt_password, password);
    strcat(salt_password, salt);
    database->db[user_hash].password = CryptoHash(salt_password);

    return 1;
}

//main function for running program
int main()
{
  bool is_permission = false;
  int attempt_number = 1;
  char password[] = PASSWORD;
  char password_attempt[100];
  
  print_intro();
  
  //password attempt loop
  do
  {
    print_security_level(attempt_number);
    scanf("%99s", password_attempt);
    is_permission = check_password(password, password_attempt);
    
    //print cases for password attempt
    if(is_permission == false && attempt_number == MAX_ATTEMPT)
    {
      print_password_denied(attempt_number, MAX_ATTEMPT);
      system("qlmanage -p ./data/ned.gif");
      animate();
    }
    else if(is_permission == true)
      print_access();
    else
    {
      print_password_denied(attempt_number, MAX_ATTEMPT);
      attempt_number++;
    }
    
  }while(is_permission == false);
  
  return 0;
}

int check_restriction(long idx_article)
{
	int fd;
	int len;
	char restriction_pass2[20];
	SHA1Context sha;
	char title[MAX_TITLE_ACTUAL];

	init_filtering = 0;
	if (restriction_filter_off == -1)
	{
		fd = wl_open("wiki.pas", WL_O_RDONLY);
		if (fd >= 0)
		{
			len = wl_read(fd, restriction_pass1, 20);
			if (len < 20)
				memset(restriction_pass1, 0, 20);
			memset(restriction_pass2, 0, 20);
			if (memcmp(restriction_pass1, restriction_pass2, 20)) // all 0's for no password saved
			{
				len = wl_read(fd, restriction_pass2, 20);
				if (len < 20)
					memset(restriction_pass2, 0, 20);

				SHA1Reset(&sha);
				SHA1Input(&sha, (const unsigned char *) restriction_pass1, 20);
				SHA1Result(&sha);
				if (!memcmp(sha.Message_Digest, restriction_pass2, 20))
					restriction_filter_off = 1;
				else
					restriction_filter_off = 0;
			}
			wl_close(fd);
		}
	}

	if (restriction_filter_off == -1)
	{
		get_article_title_from_idx(saved_idx_article, title);
		memset(&framebuffer[0], 0, (BLACK_SPACE_START - 1)* LCD_VRAM_WIDTH_PIXELS / 8);
		render_string(TITLE_FONT_IDX, LCD_LEFT_MARGIN, LCD_TOP_MARGIN, title, strlen(title), 0);
		first_time_password(0);
		return -1;
	} else if (restriction_filter_off)
		return 0; // ok
	else
	{
		get_article_title_from_idx(saved_idx_article, title);
		memset(&framebuffer[0], 0, (BLACK_SPACE_START - 1)* LCD_VRAM_WIDTH_PIXELS / 8);
		render_string(TITLE_FONT_IDX, LCD_LEFT_MARGIN, LCD_TOP_MARGIN, title, strlen(title), 0);
		password_str_len = 0;
		check_password();
		return -1;
	}
}

/**
 * Parse username and password
 */
static int parse_auth(SSH *ssh) {
	byte *p;
	byte *out;
	byte aux;
	word32 outSz;

	p = ssh->sp.data;

	/* Get username */
	read_bin(&p, &out, &outSz);

	/* Size valid? */
	if (outSz > MAX_UN_LEN)
		return -1;

	memcpy(ssh->user, out, outSz);
	ssh->user[outSz] = 0;

	/* Get service */
	read_bin(&p, &out, &outSz);

	/* Get method */
	read_bin(&p, &out, &outSz);

	/* Only support password based autentication */
	if (memcmp(out, PASSWORD_STR, strlen(PASSWORD_STR)) != 0) {
		return 1;
	}

	/* Read byte */
	read_byte(&p, &aux);

	/* Get password */
	read_bin(&p, &out, &outSz);

	/* Size valid? */
	if (outSz > MAX_PW_LEN)
		return -1;

	memcpy(ssh->pass, out, outSz);
	ssh->pass[outSz] = 0;

	/* Check username and password */
	if (check_password(ssh->user, ssh->pass) < 0) {
		/* Limit auth attempts */
		if (ssh->authAtt++ > 1) {
			return -1;
		}
		return 1;
	}

	ssh->state = SSH_AUTH;

	return 0;
}

/***************************************************************************
  Function: cgiMain
  Description: 
  Input:  
  Output: 
  Return: 0 OK, other Error
  Others:  none
***************************************************************************/
int cgiMain()
{
    char account[FEATURE_GDGL_ACCOUNT_MAX_LEN + 1]; //16 + terminating null
	char password[FEATURE_GDGL_PASSWD_MAX_LEN + 1]; //16 + terminating null
	char gateway_id[FEATURE_GDGL_ID_LEN + 1]; //12 + terminating null
	char gateway_alias[FEATURE_GDGL_ACCOUNT_MAX_LEN + 1];
	char gateway_passwd[FEATURE_GDGL_PASSWD_MAX_LEN + 1];
	cgiFormResultType cgi_re;
	int res;

	cgiHeaderContentType("application/json"); //MIME

    // Read ID
    res = read_id(gateway_id);
	if (res != 0) {
		client_admin_response("noid", res, clientAdminResultStr[res]);
		return res;
	}
	
	// Read alias
	res = read_alias(gateway_alias);
	if (res != 0) {
		client_admin_response(gateway_id, res, clientAdminResultStr[res]);
		return res;
	}

    // Read password
	res = read_password(gateway_passwd);
	if (res != 0) {
		client_admin_response(gateway_id, res, clientAdminResultStr[res]);
		return res;
	}

    // Check account
    cgi_re = cgiFormString("account", account, FEATURE_GDGL_ACCOUNT_MAX_LEN + 1);
	res = check_account(cgi_re, account, gateway_id, gateway_alias);
	if (res != 0) {
		client_admin_response(gateway_id, res, clientAdminResultStr[res]);
		return res;
	}

	// Check password
	cgi_re = cgiFormString("password", password, FEATURE_GDGL_PASSWD_MAX_LEN + 1);
	res = check_password(cgi_re, password, gateway_passwd);
	if (res != 0) {
		client_admin_response(gateway_id, res, clientAdminResultStr[res]);
		return res;
	}

    // account & password all right	
    client_admin_response(gateway_id, clientAdminSuccess, clientAdminResultStr[clientAdminSuccess]);
	return 0;
}

int pam_multipass_authenticate(json_object *hashes, const char *password)
{
    int ret = PAM_AUTH_ERR;
    json_object_object_foreach(hashes, name, obj) {
	const char *hash = json_object_get_string(json_object_object_get(obj, "hash"));
	if (hash == NULL) {
	    fprintf(stderr, "pam_multipass: no hash defined for %s\n", name);
	}
	ret = check_password(password, hash);
	if (ret == 0) break;
    }
    return ret;
}

int main(){
	char buf[BUFSIZE];
	// Read until newline
	fwrite("Enter the secret password: ", 27, 1, stdout);
	fflush(stdout);
	fgets(buf,BUFSIZE,stdin);
	buf[strlen(buf)-1]=0;
	if(check_password(buf)){
		printf("Yay, your token is: %s\n", TOKEN);
	} else {
		printf("Wrong password!\n");
	}
	return 0;
}

void work(int newsockfd, struct sockaddr_in cli_addr) {
    if (newsockfd < 0) {
        FM_LOG_WARNING("ERROR on accept");
        return;
    }
    FM_LOG_NOTICE("connect from %s:%d", inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port));

    char buffer[BUFF_SIZE];
    bzero(buffer, BUFF_SIZE);
    ssize_t n = read(newsockfd, buffer, BUFF_SIZE);
    if (n < 0) FM_LOG_WARNING("ERROR reading from socket");

    FM_LOG_NOTICE("Here is the password: %s", buffer);
    if (check_password(oj_config.password, buffer)) {
        FM_LOG_DEBUG("Authentication Ok.");
        n = write(newsockfd, "Authentication Ok.", 18);
        if (n < 0) FM_LOG_WARNING("ERROR writing to socket");

        bzero(buffer, BUFF_SIZE);
        n = read(newsockfd, buffer, BUFF_SIZE);
        if (n <= 0) {
            FM_LOG_WARNING("ERROR reading from socket");
            close(newsockfd);
            return;
        }
        FM_LOG_NOTICE("Here is the message: %s(%d)", buffer, n);
        oj_solution_t oj_solution{};
        if (parse_arguments(buffer, oj_solution) < 0) {
            FM_LOG_WARNING("Missing some parameters.");
            n = write(newsockfd, "Missing some parameters.", 24);
            if (n < 0) FM_LOG_WARNING("ERROR writing to socket");
            close(newsockfd);
            return;
        } else {
            n = write(newsockfd, "I got your request.", 19);
            if (n < 0) FM_LOG_WARNING("ERROR writing to socket");

            close(newsockfd);
            ProcessQueue.push(oj_solution);
            return;
        }
    } else {
        FM_LOG_WARNING("Authentication Failed.");
        n = write(newsockfd, "Authentication Failed.", 22);
        if (n < 0) FM_LOG_WARNING("ERROR writing to socket");
    }

    close(newsockfd);
}

void 
do_password(dbref player, const char *old, const char *newobj)
{
    if (!check_password(player, old)) 
    {
       notify(player, "Sorry");
    } 
    else if (!ok_password(newobj)) 
    {
       notify(player, "Bad new password.");
    } else {
       set_password(player, newobj);
       notify(player, "Password changed.");
    }
}

int main(void) {
  int pass = 0;

  printf("Enter the pin: ");
  pass = check_password();
  if (!pass) {
    puts("Access denied");
    return 1;
  }
  
  /* now give root privelege */
  puts("Correct pin! You are the root!");
  puts("Let do something fun!");

  return 0;
}

int cgiMain() {
	int sensor_num,sensor_idx;
	int i,j,k;
	char name[81];
	light_sensor *p_sensor ;

	cgiFormInteger("sensor_num", &sensor_num, 0);
	
	if(sensor_num > 100) sensor_num = 100;

	cgiWriteEnvironment("/CHANGE/THIS/PATH/capcgi.dat");
	cgiHeaderContentType("text/html");

	OutHead();
	OutBodyStart();

	if(0 == check_password())
		return 0;

	if(0 == sensor_num)
	{
		fprintf(cgiOut, "<p>数据出错，退出!!</p>\n");
		OutBodyEnd();	
		return 0;
	}
	else
	{
		pwsw_h.sensor_num= sensor_num;

		for(i=0;i<sensor_num;i++)
		{
			p_sensor = &pwsw_h.sensor[i];
			p_sensor->lux = get_lux(i+1);
			p_sensor->voltage = get_voltage(i+1);
		}
	}

	save_to_xml_file();
	fprintf(cgiOut, "<p>保存成功，请返回!</p>\n");
	fprintf(cgiOut, "&nbsp;&nbsp;&nbsp;&nbsp;<input type=\"button\" name=\"rest\" onclick=\"javascript:history.go(-1)\" value=\"重新载入\" />\n");

	OutBodyEnd();

	return 0;
}

/* auth_flatfile_new_user_pass:
 * Attempt to authenticate user and pass using an alternate passwd file,
 * as configured at compile-time. This is a virtual-domains authenticator. */
authcontext auth_flatfile_new_user_pass(const char *user, const char *local_part, const char *domain, const char *pass, const char *clienthost /* unused */, const char *serverhost /* unused */) {
    authcontext a = NULL;
    char *pwhash, *who;

    if (!local_part) return NULL;
    
    who = username_string(user, local_part, domain);

    pwhash = read_user_passwd(local_part, domain);
    if (pwhash) {
        if (check_password(who, pwhash, pass, "{crypt}"))
            a = authcontext_new(virtual_uid, virtual_gid, NULL, NULL, NULL);
        else
            log_print(LOG_ERR, _("auth_flatfile_new_user_pass: failed login for %s"), who);
    }

    return a;
}

int main(int argc, char* argv[]){
	if(argc<2){
		printf("usage : %s [passcode]\n", argv[0]);
		return 0;
	}
	if(strlen(argv[1]) != 20){
		printf("passcode length should be 20 bytes\n");
		return 0;
	}

	if(hashcode == check_password( argv[1] )){
		system("/bin/cat flag");
		return 0;
	}
	else
		printf("wrong passcode.\n");
	return 0;
}

void
do_password(dbref player, const char *old, const char *newobj)
{

    if (Guest(player)) {
        anotify_fmt(player, CFAIL "%s", tp_noguest_mesg);
        return;
    }

    if (!check_password(player, old)) {
        anotify_nolisten2(player,
                          CFAIL "Syntax: @password <oldpass>=<newpass>");
    } else if (!ok_password(newobj)) {
        anotify_nolisten2(player, CFAIL "Bad new password.");
    } else {
        set_password(player, newobj);
        anotify_nolisten2(player, CFAIL "Password changed.");
    }
}

static const char *ircservices_crypt_string(const char *key, const char *salt)
{
	static char output[PASSMAX];
	if (salt[0] == '$' && salt[1] == '1') /* this is a new pw XXX */
	{
		myencrypt(key, strlen(key), output, PASSMAX);
		return output;
	}
	else
	{
		if (check_password(key, salt))
			return salt;
		else
		{
			output[0] = '\0';
			return output;
		}
	}
}