#!/bin/bash

if [ $# > 0 ]; then 
	file=`cat $1`
	t=0
	for i in ${file[@]/\r\n//}
	do
		case $t in
			0) host=$i ;;	
			1) user=$i ;;
			*) pass=$i 
			t=0
			expect ./ssh.exp $host $user $pass > /dev/null
			if [ $? = 1 ]; then
				echo "$host $user $pass" >> good-ssh
			fi
		esac
		let "t+=1"
	done	
else 
	echo "Use: $0 file"
fi

#!/usr/bin/expect

proc  auth {1 2 3} {
	global result
	spawn ssh "$2@$1"
	expect { 
		"Password:" { send "$3\r" }
		
		timeout { 
			set result 0
			return 0 
		}
		"known" { 
			set result 0
			return 0 
		}
		"yes" { send "yes\r" }

	}
	expect {
		"Password:" { 
			set result 0
			return 0
		}
		"denied" {
			set result 0
			return 0 
		}
		-ex "$" {
			send "quit\r"
			set result 1
			return 1
		}
		-ex "#" {
			send "quit\r"
			set result 1
			return 1
		}
		timeout { 
			set result 0
			return 0 
		}

	}

}

set i 1
foreach arg $argv {
	if { $i == 1 } { set host $arg }
	if { $i == 2 } { set login $arg }
	if { $i == 3 } { set pass $arg }
	incr i
}
	auth $host $login $pass
	exit $result

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <libssh2.h>

#define MAX_SIZE 0xff

FILE *f;
char *hostloginpass [3];
int sock;
//LIBSSH2_SESSION *session;

void usage (char *name)
{
  printf ("Usage: %s [input_file]\n", name);
}

void clear_file ()
{
  fclose (f);
}

void clear_file_and_array ()
{
  int i;

  fclose (f);
  for (i = 0; i < 3; i++)
  {
    //printf ("LOL: %s\n", hostloginpass [i]);
    free (hostloginpass [i]);
  }
  //clear_file ();
}

void clear_file_and_array_and_socket ()
{
  int i;
  //printf ("HOST: %s\n", hostloginpass [0]);
  close (sock);
  fclose (f);
  for (i = 0; i < 3; i++)
  {
    //printf ("LOL: %s\n", hostloginpass [i]);
    free (hostloginpass [i]);
  }
  //clear_file_and_array ();
}

int create_socket (char *host, int port)
{
  int s;
  struct sockaddr_in sin;
  int i = 1, failed = 1;

  if ((s = socket (AF_INET, SOCK_STREAM, 0)) < 0)
    return -1;
  memset (&sin, '\0', sizeof (struct sockaddr_in));
  sin.sin_family = AF_INET;
  sin.sin_port = htons (port);
  sin.sin_addr.s_addr = inet_addr (host);
  /*if (bind (s, (struct sockaddr *) &sin, sizeof (struct sockaddr_in)) < 0)
    return -2;*/
  while ((i < 10) && (failed == 1))
  {
  if (connect (s, (struct sockaddr *) &sin, sizeof (struct sockaddr_in)) < 0)
  {
    //printf ("I: %d\nFAILED: %d\n", i, failed);
    i++;
  }
  else
    failed = 0;
    //return -2;
  }
  //printf ("I: %d\nFAILED: %d\n", i, failed);
  if (i == 10)
    return -2;
  return s;
}

int testlogin (int s, char *login, char *pass)
{
  LIBSSH2_SESSION *session;
  int res;
  char *fp;

  session = libssh2_session_init ();
  if (libssh2_session_startup (session, s))
  {
    return -1;
  }
  /*fp = libssh2_userauth_list (session, login, strlen (login));
  printf ("FP: %s\n", fp);*/
  if (libssh2_userauth_password (session, login, pass))
    res = 0;
  else
    res = 1;
  libssh2_session_free (session);
  return res;
}

int main (int argc, char **argv)
{
  char fname [MAX_SIZE];
  static char line [MAX_SIZE];
  int line_count/*, is_first_line = 1*/;
  unsigned char i;
  char *pline, *find_char;
  struct stat st;
  FILE *f;
  struct sockaddr_in sin;

  if (argc != 2)
  {
    usage (argv [0]);
    return 0;
  }
  bzero (fname, MAX_SIZE);
  bzero (&st, sizeof (struct stat));
  strncpy (fname, argv [1], strlen (argv [1]));
  if ((stat (fname, (struct stat *) &st)) < 0)
  {
    printf ("%s: stat() error: %s\n", fname, strerror (errno));
    return -1;
  }
  //printf ("STAT: %lo\n", st.st_mode & S_IFREG);
  if ((st.st_mode & S_IFREG) != S_IFREG)
  {
    printf ("%s: not regular file or symlink.\n", fname);
    return -1;
  }
  if ((f = fopen (fname, "r")) == NULL)
  {
    printf ("%s: open failure. Error: %s\n", fname, strerror (errno));
    return -1;
  }
  while (!feof (f))
  {
    bzero (line, MAX_SIZE);
    if (fgets (line, MAX_SIZE, f) != NULL)
    {
      if (sizeof (line) > MAX_SIZE)
      {
        printf ("Segmentation fault :)\n");
        fclose (f);
        return -1;
      }
      *(unsigned char *) (line + strlen (line) - 1) = '\0';

      /*if (is_first_line)
      {
        line_count = atoi (line);
        is_first_line = 0;
        continue;
      }*/
      pline = find_char = line;
      while ((find_char = strchr (find_char, 0x20)) != NULL)
      {
        (*(unsigned char *) find_char) = '\0';
        find_char++;
        //printf ("FIND_CHAR: %s\nLINE: %s\n", find_char, pline);
      }
      //printf ("HOST: %s\n", pline);
      //pline += (strlen (pline) + 1);
      for (i = 0; i < 3; i++)
      {
        if ((hostloginpass[i] = calloc (strlen (pline), 1)) == NULL)
        {
          printf ("calloc() error: %s\n", strerror (errno));
          fclose (f);
          return -1;
        }
        strncpy (hostloginpass [i], pline, strlen (pline));
        pline += (strlen (pline) + 1);
      }
      //printf ("USER: %s\n", hostloginpass [2]);

      sock = create_socket (hostloginpass [0], 22);
      //printf ("USER: %s\n", hostloginpass [0]);
      switch (sock)
      {
        case -1:
          printf ("socket1() error: %s\n", strerror (errno));
          clear_file_and_array ();
          return -1;
          break;
        case -2:
          printf ("socket2() error: %s\n", strerror (errno));
          //printf ("USER: %s\n", hostloginpass [0]);
          clear_file_and_array_and_socket ();
          return -1;
          break;
        default:
          break;
      }
      //printf ("Socket Created\n");
      printf ("Trying %s:%s on host %s... ", hostloginpass [1], hostloginpass [2], hostloginpass [0]);
      switch (testlogin (sock, hostloginpass [1], hostloginpass [2]))
      {
        case -1:
          printf ("ssh_connect() error: %s\n", strerror (errno));
          clear_file_and_array_and_socket ();
          return -1;
          break;
        case 0:
          printf ("- fail\n");
          break;
        case 1:
          printf ("- ok\n");
          break;
        default:
          break;
      }
      close (sock);

      for (i = 0; i < 3; i++)
        free (hostloginpass [i]);
      //printf ("%s", line);
    }
  }
  fclose (f);
  return 0;
}

#!/usr/bin/perl

use Fcntl ':mode';
use Net::SSH2;
###### Config options ######
$input_file = 'ssh.txt';
$bad_file = 'bad.txt';
$good_file = 'good.txt';
############################

$res = getfilestat ($input_file);
die $input_file . ": error: " . $! . "\n" if ($res < 0);

open (INPUT, "<$input_file") || die "$input_file: error: " . $! . "\n";
open (BAD, ">$bad_file") || die "$bad_file: error: " . $! . "\n";
open (GOOD, ">$good_file") || die "$good_file: error: " . $! . "\n";
while (<INPUT>)
{
  $_ =~ s/\n$//;
  $_ =~ s/\s*$//;
  $_ =~ s/^\s*//;
  $_ =~ s/\s+/ /g;
  ($host, $user, $pass) = (split (/ /, $_))[0,1,2];
  $ssh = Net::SSH2->new ();
  $ssh->connect ($host, 22) || die "$host: connection refused: " . $! . "\n";
  print "Trying $host\@$user:$pass...\n";
  $islogin = $ssh->auth_password ($user, $pass);
  if (!$islogin)
  {
    print BAD "$host\@$user:$pass\n";
  }
  else
  {
    print GOOD "$host\@$user:$pass\n";
  }
}
close GOOD;
close BAD;
close INPUT;
print "Checking complete\n";
exit 0;

sub getfilestat ($)
{
  my ($fname) = @_;
  my ($mode);

  $mode = (stat ($fname))[2];
  (($mode & S_IFREG) == S_IFREG) ? return 0 : return -1;
}