diff --git a/3rdparty/phpass/PasswordHash.php b/3rdparty/phpass/PasswordHash.php
new file mode 100644
index 0000000000..12958c7f19
--- /dev/null
+++ b/3rdparty/phpass/PasswordHash.php
@@ -0,0 +1,253 @@
+<?php
+#
+# Portable PHP password hashing framework.
+#
+# Version 0.3 / genuine.
+#
+# Written by Solar Designer <solar at openwall.com> in 2004-2006 and placed in
+# the public domain.  Revised in subsequent years, still public domain.
+#
+# There's absolutely no warranty.
+#
+# The homepage URL for this framework is:
+#
+#	http://www.openwall.com/phpass/
+#
+# Please be sure to update the Version line if you edit this file in any way.
+# It is suggested that you leave the main version number intact, but indicate
+# your project name (after the slash) and add your own revision information.
+#
+# Please do not change the "private" password hashing method implemented in
+# here, thereby making your hashes incompatible.  However, if you must, please
+# change the hash type identifier (the "$P$") to something different.
+#
+# Obviously, since this code is in the public domain, the above are not
+# requirements (there can be none), but merely suggestions.
+#
+class PasswordHash {
+	var $itoa64;
+	var $iteration_count_log2;
+	var $portable_hashes;
+	var $random_state;
+
+	function PasswordHash($iteration_count_log2, $portable_hashes)
+	{
+		$this->itoa64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+
+		if ($iteration_count_log2 < 4 || $iteration_count_log2 > 31)
+			$iteration_count_log2 = 8;
+		$this->iteration_count_log2 = $iteration_count_log2;
+
+		$this->portable_hashes = $portable_hashes;
+
+		$this->random_state = microtime();
+		if (function_exists('getmypid'))
+			$this->random_state .= getmypid();
+	}
+
+	function get_random_bytes($count)
+	{
+		$output = '';
+		if (is_readable('/dev/urandom') &&
+		    ($fh = @fopen('/dev/urandom', 'rb'))) {
+			$output = fread($fh, $count);
+			fclose($fh);
+		}
+
+		if (strlen($output) < $count) {
+			$output = '';
+			for ($i = 0; $i < $count; $i += 16) {
+				$this->random_state =
+				    md5(microtime() . $this->random_state);
+				$output .=
+				    pack('H*', md5($this->random_state));
+			}
+			$output = substr($output, 0, $count);
+		}
+
+		return $output;
+	}
+
+	function encode64($input, $count)
+	{
+		$output = '';
+		$i = 0;
+		do {
+			$value = ord($input[$i++]);
+			$output .= $this->itoa64[$value & 0x3f];
+			if ($i < $count)
+				$value |= ord($input[$i]) << 8;
+			$output .= $this->itoa64[($value >> 6) & 0x3f];
+			if ($i++ >= $count)
+				break;
+			if ($i < $count)
+				$value |= ord($input[$i]) << 16;
+			$output .= $this->itoa64[($value >> 12) & 0x3f];
+			if ($i++ >= $count)
+				break;
+			$output .= $this->itoa64[($value >> 18) & 0x3f];
+		} while ($i < $count);
+
+		return $output;
+	}
+
+	function gensalt_private($input)
+	{
+		$output = '$P$';
+		$output .= $this->itoa64[min($this->iteration_count_log2 +
+			((PHP_VERSION >= '5') ? 5 : 3), 30)];
+		$output .= $this->encode64($input, 6);
+
+		return $output;
+	}
+
+	function crypt_private($password, $setting)
+	{
+		$output = '*0';
+		if (substr($setting, 0, 2) == $output)
+			$output = '*1';
+
+		$id = substr($setting, 0, 3);
+		# We use "$P$", phpBB3 uses "$H$" for the same thing
+		if ($id != '$P$' && $id != '$H$')
+			return $output;
+
+		$count_log2 = strpos($this->itoa64, $setting[3]);
+		if ($count_log2 < 7 || $count_log2 > 30)
+			return $output;
+
+		$count = 1 << $count_log2;
+
+		$salt = substr($setting, 4, 8);
+		if (strlen($salt) != 8)
+			return $output;
+
+		# We're kind of forced to use MD5 here since it's the only
+		# cryptographic primitive available in all versions of PHP
+		# currently in use.  To implement our own low-level crypto
+		# in PHP would result in much worse performance and
+		# consequently in lower iteration counts and hashes that are
+		# quicker to crack (by non-PHP code).
+		if (PHP_VERSION >= '5') {
+			$hash = md5($salt . $password, TRUE);
+			do {
+				$hash = md5($hash . $password, TRUE);
+			} while (--$count);
+		} else {
+			$hash = pack('H*', md5($salt . $password));
+			do {
+				$hash = pack('H*', md5($hash . $password));
+			} while (--$count);
+		}
+
+		$output = substr($setting, 0, 12);
+		$output .= $this->encode64($hash, 16);
+
+		return $output;
+	}
+
+	function gensalt_extended($input)
+	{
+		$count_log2 = min($this->iteration_count_log2 + 8, 24);
+		# This should be odd to not reveal weak DES keys, and the
+		# maximum valid value is (2**24 - 1) which is odd anyway.
+		$count = (1 << $count_log2) - 1;
+
+		$output = '_';
+		$output .= $this->itoa64[$count & 0x3f];
+		$output .= $this->itoa64[($count >> 6) & 0x3f];
+		$output .= $this->itoa64[($count >> 12) & 0x3f];
+		$output .= $this->itoa64[($count >> 18) & 0x3f];
+
+		$output .= $this->encode64($input, 3);
+
+		return $output;
+	}
+
+	function gensalt_blowfish($input)
+	{
+		# This one needs to use a different order of characters and a
+		# different encoding scheme from the one in encode64() above.
+		# We care because the last character in our encoded string will
+		# only represent 2 bits.  While two known implementations of
+		# bcrypt will happily accept and correct a salt string which
+		# has the 4 unused bits set to non-zero, we do not want to take
+		# chances and we also do not want to waste an additional byte
+		# of entropy.
+		$itoa64 = './ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+
+		$output = '$2a$';
+		$output .= chr(ord('0') + $this->iteration_count_log2 / 10);
+		$output .= chr(ord('0') + $this->iteration_count_log2 % 10);
+		$output .= '$';
+
+		$i = 0;
+		do {
+			$c1 = ord($input[$i++]);
+			$output .= $itoa64[$c1 >> 2];
+			$c1 = ($c1 & 0x03) << 4;
+			if ($i >= 16) {
+				$output .= $itoa64[$c1];
+				break;
+			}
+
+			$c2 = ord($input[$i++]);
+			$c1 |= $c2 >> 4;
+			$output .= $itoa64[$c1];
+			$c1 = ($c2 & 0x0f) << 2;
+
+			$c2 = ord($input[$i++]);
+			$c1 |= $c2 >> 6;
+			$output .= $itoa64[$c1];
+			$output .= $itoa64[$c2 & 0x3f];
+		} while (1);
+
+		return $output;
+	}
+
+	function HashPassword($password)
+	{
+		$random = '';
+
+		if (CRYPT_BLOWFISH == 1 && !$this->portable_hashes) {
+			$random = $this->get_random_bytes(16);
+			$hash =
+			    crypt($password, $this->gensalt_blowfish($random));
+			if (strlen($hash) == 60)
+				return $hash;
+		}
+
+		if (CRYPT_EXT_DES == 1 && !$this->portable_hashes) {
+			if (strlen($random) < 3)
+				$random = $this->get_random_bytes(3);
+			$hash =
+			    crypt($password, $this->gensalt_extended($random));
+			if (strlen($hash) == 20)
+				return $hash;
+		}
+
+		if (strlen($random) < 6)
+			$random = $this->get_random_bytes(6);
+		$hash =
+		    $this->crypt_private($password,
+		    $this->gensalt_private($random));
+		if (strlen($hash) == 34)
+			return $hash;
+
+		# Returning '*' on error is safe here, but would _not_ be safe
+		# in a crypt(3)-like function used _both_ for generating new
+		# hashes and for validating passwords against existing hashes.
+		return '*';
+	}
+
+	function CheckPassword($password, $stored_hash)
+	{
+		$hash = $this->crypt_private($password, $stored_hash);
+		if ($hash[0] == '*')
+			$hash = crypt($password, $stored_hash);
+
+		return $hash == $stored_hash;
+	}
+}
+
+?>
diff --git a/3rdparty/phpass/c/Makefile b/3rdparty/phpass/c/Makefile
new file mode 100644
index 0000000000..fe48917f7f
--- /dev/null
+++ b/3rdparty/phpass/c/Makefile
@@ -0,0 +1,21 @@
+#
+# Written by Solar Designer and placed in the public domain.
+# See crypt_private.c for more information.
+#
+CC = gcc
+LD = $(CC)
+RM = rm -f
+CFLAGS = -Wall -O2 -fomit-frame-pointer -funroll-loops
+LDFLAGS = -s
+LIBS = -lcrypto
+
+all: crypt_private-test
+
+crypt_private-test: crypt_private-test.o
+	$(LD) $(LDFLAGS) $(LIBS) crypt_private-test.o -o $@
+
+crypt_private-test.o: crypt_private.c
+	$(CC) -c $(CFLAGS) crypt_private.c -DTEST -o $@
+
+clean:
+	$(RM) crypt_private-test*
diff --git a/3rdparty/phpass/c/crypt_private.c b/3rdparty/phpass/c/crypt_private.c
new file mode 100644
index 0000000000..6abc05bc1d
--- /dev/null
+++ b/3rdparty/phpass/c/crypt_private.c
@@ -0,0 +1,106 @@
+/*
+ * This code exists for the sole purpose to serve as another implementation
+ * of the "private" password hashing method implemened in PasswordHash.php
+ * and thus to confirm that these password hashes are indeed calculated as
+ * intended.
+ *
+ * Other uses of this code are discouraged.  There are much better password
+ * hashing algorithms available to C programmers; one of those is bcrypt:
+ *
+ *	http://www.openwall.com/crypt/
+ *
+ * Written by Solar Designer <solar at openwall.com> in 2005 and placed in
+ * the public domain.
+ *
+ * There's absolutely no warranty.
+ */
+
+#include <string.h>
+#include <openssl/md5.h>
+
+#ifdef TEST
+#include <stdio.h>
+#endif
+
+static char *itoa64 =
+	"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+static void encode64(char *dst, char *src, int count)
+{
+	int i, value;
+
+	i = 0;
+	do {
+		value = (unsigned char)src[i++];
+		*dst++ = itoa64[value & 0x3f];
+		if (i < count)
+			value |= (unsigned char)src[i] << 8;
+		*dst++ = itoa64[(value >> 6) & 0x3f];
+		if (i++ >= count)
+			break;
+		if (i < count)
+			value |= (unsigned char)src[i] << 16;
+		*dst++ = itoa64[(value >> 12) & 0x3f];
+		if (i++ >= count)
+			break;
+		*dst++ = itoa64[(value >> 18) & 0x3f];
+	} while (i < count);
+}
+
+char *crypt_private(char *password, char *setting)
+{
+	static char output[35];
+	MD5_CTX ctx;
+	char hash[MD5_DIGEST_LENGTH];
+	char *p, *salt;
+	int count_log2, length, count;
+
+	strcpy(output, "*0");
+	if (!strncmp(setting, output, 2))
+		output[1] = '1';
+
+	if (strncmp(setting, "$P$", 3))
+		return output;
+
+	p = strchr(itoa64, setting[3]);
+	if (!p)
+		return output;
+	count_log2 = p - itoa64;
+	if (count_log2 < 7 || count_log2 > 30)
+		return output;
+
+	salt = setting + 4;
+	if (strlen(salt) < 8)
+		return output;
+
+	length = strlen(password);
+
+	MD5_Init(&ctx);
+	MD5_Update(&ctx, salt, 8);
+	MD5_Update(&ctx, password, length);
+	MD5_Final(hash, &ctx);
+
+	count = 1 << count_log2;
+	do {
+		MD5_Init(&ctx);
+		MD5_Update(&ctx, hash, MD5_DIGEST_LENGTH);
+		MD5_Update(&ctx, password, length);
+		MD5_Final(hash, &ctx);
+	} while (--count);
+
+	memcpy(output, setting, 12);
+	encode64(&output[12], hash, MD5_DIGEST_LENGTH);
+
+	return output;
+}
+
+#ifdef TEST
+int main(int argc, char **argv)
+{
+	if (argc != 3) return 1;
+
+	puts(crypt_private(argv[1], argv[2]));
+
+	return 0;
+}
+#endif
diff --git a/3rdparty/phpass/test.php b/3rdparty/phpass/test.php
new file mode 100644
index 0000000000..2f4a41c8c3
--- /dev/null
+++ b/3rdparty/phpass/test.php
@@ -0,0 +1,72 @@
+<?php
+#
+# This is a test program for the portable PHP password hashing framework.
+#
+# Written by Solar Designer and placed in the public domain.
+# See PasswordHash.php for more information.
+#
+
+require 'PasswordHash.php';
+
+header('Content-type: text/plain');
+
+$ok = 0;
+
+# Try to use stronger but system-specific hashes, with a possible fallback to
+# the weaker portable hashes.
+$t_hasher = new PasswordHash(8, FALSE);
+
+$correct = 'test12345';
+$hash = $t_hasher->HashPassword($correct);
+
+print 'Hash: ' . $hash . "\n";
+
+$check = $t_hasher->CheckPassword($correct, $hash);
+if ($check) $ok++;
+print "Check correct: '" . $check . "' (should be '1')\n";
+
+$wrong = 'test12346';
+$check = $t_hasher->CheckPassword($wrong, $hash);
+if (!$check) $ok++;
+print "Check wrong: '" . $check . "' (should be '0' or '')\n";
+
+unset($t_hasher);
+
+# Force the use of weaker portable hashes.
+$t_hasher = new PasswordHash(8, TRUE);
+
+$hash = $t_hasher->HashPassword($correct);
+
+print 'Hash: ' . $hash . "\n";
+
+$check = $t_hasher->CheckPassword($correct, $hash);
+if ($check) $ok++;
+print "Check correct: '" . $check . "' (should be '1')\n";
+
+$check = $t_hasher->CheckPassword($wrong, $hash);
+if (!$check) $ok++;
+print "Check wrong: '" . $check . "' (should be '0' or '')\n";
+
+# A correct portable hash for 'test12345'.
+# Please note the use of single quotes to ensure that the dollar signs will
+# be interpreted literally.  Of course, a real application making use of the
+# framework won't store password hashes within a PHP source file anyway.
+# We only do this for testing.
+$hash = '$P$9IQRaTwmfeRo7ud9Fh4E2PdI0S3r.L0';
+
+print 'Hash: ' . $hash . "\n";
+
+$check = $t_hasher->CheckPassword($correct, $hash);
+if ($check) $ok++;
+print "Check correct: '" . $check . "' (should be '1')\n";
+
+$check = $t_hasher->CheckPassword($wrong, $hash);
+if (!$check) $ok++;
+print "Check wrong: '" . $check . "' (should be '0' or '')\n";
+
+if ($ok == 6)
+	print "All tests have PASSED\n";
+else
+	print "Some tests have FAILED\n";
+
+?>
diff --git a/lib/user/database.php b/lib/user/database.php
index 452709c1fb..3eade276dd 100644
--- a/lib/user/database.php
+++ b/lib/user/database.php
@@ -33,12 +33,28 @@
  *
  */
 
+require_once 'phpass/PasswordHash.php';
+
 /**
  * Class for user management in a SQL Database (e.g. MySQL, SQLite)
  */
 class OC_User_Database extends OC_User_Backend {
 	static private $userGroupCache=array();
+	/**
+	 * @var PasswordHash
+	 */
+	static private $hasher=null;
+	
+	private function getHasher(){
+		if(!self::$hasher){
+			//we don't want to use DES based crypt(), since it doesn't return a has with a recognisable prefix
+			$forcePortable=(CRYPT_BLOWFISH!=1);
+			self::$hasher=new PasswordHash(8,$forcePortable);
+		}
+		return self::$hasher;
 
+	}
+	
 	/**
 	 * @brief Create a new user
 	 * @param $uid The username of the user to create
@@ -51,10 +67,11 @@ class OC_User_Database extends OC_User_Backend {
 	public function createUser( $uid, $password ){
 		if( $this->userExists($uid) ){
 			return false;
-		}
-		else{
+		}else{
+			$hasher=$this->getHasher();
+			$hash = $hasher->HashPassword($password);
 			$query = OC_DB::prepare( "INSERT INTO `*PREFIX*users` ( `uid`, `password` ) VALUES( ?, ? )" );
-			$result = $query->execute( array( $uid, sha1( $password )));
+			$result = $query->execute( array( $uid, $hash));
 
 			return $result ? true : false;
 		}
@@ -84,8 +101,10 @@ class OC_User_Database extends OC_User_Backend {
 	 */
 	public function setPassword( $uid, $password ){
 		if( $this->userExists($uid) ){
+			$hasher=$this->getHasher();
+			$hash = $hasher->HashPassword($password);
 			$query = OC_DB::prepare( "UPDATE *PREFIX*users SET password = ? WHERE uid = ?" );
-			$result = $query->execute( array( sha1( $password ), $uid ));
+			$result = $query->execute( array( $hash, $uid ));
 
 			return true;
 		}
@@ -103,12 +122,28 @@ class OC_User_Database extends OC_User_Backend {
 	 * Check if the password is correct without logging in the user
 	 */
 	public function checkPassword( $uid, $password ){
-		$query = OC_DB::prepare( "SELECT uid FROM *PREFIX*users WHERE uid LIKE ? AND password = ?" );
-		$result = $query->execute( array( $uid, sha1( $password )));
+		$query = OC_DB::prepare( "SELECT uid, password FROM *PREFIX*users WHERE uid LIKE ?" );
+		$result = $query->execute( array( $uid));
 
 		$row=$result->fetchRow();
 		if($row){
-			return $row['uid'];
+			$storedHash=$row['password'];
+			if (substr($storedHash,0,1)=='$'){//the new phpass based hashing
+				$hasher=$this->getHasher();
+				if($hasher->CheckPassword($password, $storedHash)){
+					return $row['uid'];
+				}else{
+					return false;
+				}
+			}else{//old sha1 based hashing
+				if(sha1($password)==$storedHash){
+					//upgrade to new hashing
+					$this->setPassword($row['uid'],$password);
+					return $row['uid'];
+				}else{
+					return false;
+				}
+			}
 		}else{
 			return false;
 		}