server/apps/files_encryption/lib/proxy.php

<?php

/**
* ownCloud
*
* @author Sam Tuke, Robin Appelman
* @copyright 2012 Sam Tuke samtuke@owncloud.com, Robin Appelman 
* icewind1991@gmail.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
* License as published by the Free Software Foundation; either
* version 3 of the License, or any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU AFFERO GENERAL PUBLIC LICENSE for more details.
*
* You should have received a copy of the GNU Affero General Public
* License along with this library.  If not, see <http://www.gnu.org/licenses/>.
*
*/


/**
 * transparent encryption
 */

namespace OCA\Encryption;

class Proxy extends \OC_FileProxy {

	private static $blackList = null; //mimetypes blacklisted from encryption
	
	private static $enableEncryption = null;
	
	/**
	 * Check if a file requires encryption
	 * @param string $path
	 * @return bool
	 *
	 * Tests if server side encryption is enabled, and file is allowed by blacklists
	 */
	private static function shouldEncrypt( $path ) {
		
		if ( is_null( self::$enableEncryption ) ) {
		
			if ( 
			\OCP\Config::getAppValue( 'files_encryption', 'enable_encryption', 'true' ) == 'true' 
			&& Crypt::mode() == 'server' 
			) {
			
				self::$enableEncryption = true;
			
			} else {
				
				self::$enableEncryption = false;
			
			}
			
		}
		
		if ( !self::$enableEncryption ) {
		
			return false;
			
		}
		
		if ( is_null(self::$blackList ) ) {
		
			self::$blackList = explode(',', \OCP\Config::getAppValue( 'files_encryption','type_blacklist','jpg,png,jpeg,avi,mpg,mpeg,mkv,mp3,oga,ogv,ogg' ) );
			
		}
		
		if ( Crypt::isEncryptedContent( $path ) ) {
		
			return true;
			
		}
		
		$extension = substr( $path, strrpos( $path,'.' ) +1 );
		
		if ( array_search( $extension, self::$blackList ) === false ){
		
			return true;
			
		}
		
		return false;
	}

	/**
	 * Check if a file is encrypted according to database file cache
	 * @param string $path
	 * @return bool
	 */
	private static function isEncrypted( $path ){
	
		// Fetch all file metadata from DB
		$metadata = \OC_FileCache_Cached::get( $path, '' );
		
		// Return encryption status
		return isset( $metadata['encrypted'] ) and ( bool )$metadata['encrypted'];
	
	}
	
	public function preFile_put_contents( $path, &$data ) {
		
		if ( self::shouldEncrypt( $path ) ) {
		
			if ( !is_resource( $data ) ) { //stream put contents should have been converter to fopen
			
				// Set the filesize for userland, before encrypting
				$size = strlen( $data );
				
				// Disable encryption proxy to prevent recursive calls
				\OC_FileProxy::$enabled = false;
				
				// Encrypt plain data and fetch key
				$encrypted = Crypt::keyEncryptKeyfile( $data, Keymanager::getPublicKey() );
				
				// Replace plain content with encrypted content by reference
				$data = $encrypted['data'];
				
				$filePath = explode( '/', $path );
				
				$filePath = array_slice( $filePath, 3 );
				
				$filePath = '/' . implode( '/', $filePath );
				
				# TODO: make keyfile dir dynamic from app config
				$view = new \OC_FilesystemView( '/' . \OCP\USER::getUser() . '/files_encryption/keyfiles' );
				
				// Save keyfile for newly encrypted file in parallel directory tree
				Keymanager::setFileKey( $filePath, $encrypted['key'], $view, '\OC_DB' );
				
				// Update the file cache with file info
				\OC_FileCache::put( $path, array( 'encrypted'=>true, 'size' => $size ), '' );
				
				// Re-enable proxy - our work is done
				\OC_FileProxy::$enabled = true;
				
			}
		}
		
	}
	
	public function postFile_get_contents( $path, $data ) {
	
		# TODO: Use dependency injection to add required args for view and user etc. to this method
	
		if ( Crypt::mode() == 'server' && Crypt::isEncryptedContent( $data ) ) {
		
			$filePath = explode( '/', $path );
			
			$filePath = array_slice( $filePath, 3 );
			
			$filePath = '/' . implode( '/', $filePath );
			
			$cached = \OC_FileCache_Cached::get( $path, '' );
			
			// Disable encryption proxy to prevent recursive calls
			\OC_FileProxy::$enabled = false;
			
			$keyFile = Keymanager::getFileKey( $filePath );
			
			$data = Crypt::keyDecryptKeyfile( $data, $keyFile, $_SESSION['enckey'] );
			
			\OC_FileProxy::$enabled = true;
		
		}
		
		return $data;
		
	}
	
	public function postFopen( $path, &$result ){
	
		if ( !$result ) {
		
			return $result;
			
		}
		
		// Disable encryption proxy to prevent recursive calls
		\OC_FileProxy::$enabled = false;
		
		$meta = stream_get_meta_data( $result );
		
		$view = new \OC_FilesystemView();
		
		$util = new Util( $view, \OCP\USER::getUser());
		
		// If file is encrypted, decrypt using crypto protocol
		if ( Crypt::mode() == 'server' && $util->isEncryptedPath( $path ) ) {
		
			$tmp = fopen( 'php://temp' );
			
			\OCP\Files::streamCopy( $result, $tmp );
			
			fclose( $result );
			
			$encrypted = $view->file_get_contents( $path );
			
			//file_put_contents('/home/samtuke/newtmp.txt', "\$path = $path, \$data = $data" );
			
			// Replace the contents of 
			\OC_Filesystem::file_put_contents( $path, $tmp );
			
			fclose( $tmp );
			
			//file_put_contents('/home/samtuke/newtmp.txt', file_get_contents( 'crypt://' . $path ) );
			
			$result = fopen( 'crypt://' . $path, $meta['mode'] );
		
// 			file_put_contents('/home/samtuke/newtmp.txt', "mode= server" );
		
// 			$keyFile = Keymanager::getFileKey( $filePath );
// 		
// 			$tmp = tmpfile();
// 			
// 			file_put_contents( $tmp, Crypt::keyDecryptKeyfile( $result, $keyFile, $_SESSION['enckey'] ) );
// 		
// 			fclose ( $result );
// 			
// 			$result = fopen( $tmp );
			
		} /*elseif ( 
		self::shouldEncrypt( $path ) 
		and $meta ['mode'] != 'r' 
		and $meta['mode'] != 'rb' 
		) {
		
		# TODO: figure out what this does
		
			if ( 
			\OC_Filesystem::file_exists( $path ) 
			and \OC_Filesystem::filesize( $path ) > 0 
			) {
			
				//first encrypt the target file so we don't end up with a half encrypted file
				\OCP\Util::writeLog( 'files_encryption', 'Decrypting '.$path.' before writing', \OCP\Util::DEBUG );
				
				$tmp = fopen( 'php://temp' );
				
				\OCP\Files::streamCopy( $result, $tmp );
				
				// Close the original stream, we'll return another one
				fclose( $result );
				
				\OC_Filesystem::file_put_contents( $path, $tmp );
				
				fclose( $tmp );
			
			}
			
			$result = fopen( 'crypt://'.$path, $meta['mode'] );
		
		}*/
		
		// Re-enable the proxy
		\OC_FileProxy::$enabled = true;
		
		return $result;
	
	}

	public function postGetMimeType($path,$mime){
		if( Crypt::isEncryptedContent($path)){
			$mime = \OCP\Files::getMimeType('crypt://'.$path,'w');
		}
		return $mime;
	}

	public function postStat($path,$data){
		if( Crypt::isEncryptedContent($path)){
			$cached=  \OC_FileCache_Cached::get($path,'');
			$data['size']=$cached['size'];
		}
		return $data;
	}

	public function postFileSize($path,$size){
		if( Crypt::isEncryptedContent($path)){
			$cached = \OC_FileCache_Cached::get($path,'');
			return  $cached['size'];
		}else{
			return $size;
		}
	}
}