<?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/>.
*
*/

/**
* @brief Encryption proxy which handles filesystem operations before and after
*        execution and encrypts, and handles keyfiles accordingly. Used for 
*        webui.
*/

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', '' ) );
			
		}
		
		if ( Crypt::isCatfileContent( $path ) ) {
		
			return true;
			
		}
		
		$extension = substr( $path, strrpos( $path, '.' ) +1 );
		
		if ( array_search( $extension, self::$blackList ) === false ) {
		
			return true;
			
		}
		
		return false;
	}
	
	public function preFile_put_contents( $path, &$data ) {

        if ( self::shouldEncrypt( $path ) ) {

        	// Stream put contents should have been converted to fopen
			if ( !is_resource( $data ) ) {

                $userId = \OCP\USER::getUser();
				$rootView = new \OC_FilesystemView( '/' );
				$util = new Util( $rootView, $userId );
				$session = new Session( $rootView );
				$privateKey = $session->getPrivateKey();
				$filePath = $util->stripUserFilesPath( $path );
				// Set the filesize for userland, before encrypting
				$size = strlen( $data );
				
				// Disable encryption proxy to prevent recursive calls
                $proxyStatus = \OC_FileProxy::$enabled;
                \OC_FileProxy::$enabled = false;
				
				// Check if there is an existing key we can reuse
				if ( $encKeyfile = Keymanager::getFileKey( $rootView, $userId, $filePath ) ) {
					
					// Fetch shareKey
					$shareKey = Keymanager::getShareKey( $rootView, $userId, $filePath );
					
					// Decrypt the keyfile
					$plainKey = Crypt::multiKeyDecrypt( $encKeyfile, $shareKey, $privateKey );
				
				} else {
				
					// Make a new key
					$plainKey = Crypt::generateKey();
				
				}
				
				// Encrypt data
				$encData = Crypt::symmetricEncryptFileContent( $data, $plainKey );
				
				$sharingEnabled = \OCP\Share::isEnabled();
				
				$uniqueUserIds = $util->getSharingUsersArray( $sharingEnabled, $filePath, $userId );

                // Fetch public keys for all users who will share the file
				$publicKeys = Keymanager::getPublicKeys( $rootView, $uniqueUserIds );

                // Encrypt plain keyfile to multiple sharefiles
				$multiEncrypted = Crypt::multiKeyEncrypt( $plainKey, $publicKeys );
				
				// Save sharekeys to user folders
				Keymanager::setShareKeys( $rootView, $filePath, $multiEncrypted['keys'] );
				
				// Set encrypted keyfile as common varname
				$encKey = $multiEncrypted['data'];
				
				// Save keyfile for newly encrypted file in parallel directory tree
				Keymanager::setFileKey( $rootView, $filePath, $userId, $encKey );

				// Replace plain content with encrypted content by reference
				$data = $encData;
				
				// Update the file cache with file info
				\OC\Files\Filesystem::putFileInfo( $path, array( 'encrypted'=>true, 'size' => $size ), '' );
				
				// Re-enable proxy - our work is done
				\OC_FileProxy::$enabled = $proxyStatus;
				
			}
		}

        return true;
	}
	
	/**
	 * @param string $path Path of file from which has been read
	 * @param string $data Data that has been read from file
	 */
	public function postFile_get_contents( $path, $data ) {

        // FIXME: $path for shared files is just /uid/files/Shared/filepath
		
		$userId = \OCP\USER::getUser();
		$view = new \OC_FilesystemView( '/' );
		$util = new Util( $view, $userId );
		
		$relPath = $util->stripUserFilesPath( $path );
		
	
		// TODO check for existing key file and reuse it if possible to avoid problems with versioning etc.
		// Disable encryption proxy to prevent recursive calls
        $proxyStatus = \OC_FileProxy::$enabled;
        \OC_FileProxy::$enabled = false;

        // If data is a catfile
		if ( 
			Crypt::mode() == 'server' 
			&& Crypt::isCatfileContent( $data ) // TODO: Do we really need this check? Can't we assume it is properly encrypted?
		) {
		
			// TODO: use get owner to find correct location of key files for shared files
			$session = new Session( $view );
			$privateKey = $session->getPrivateKey( $userId );
			
			// Get the encrypted keyfile
			$encKeyfile = Keymanager::getFileKey( $view, $userId, $relPath );
			
			// Attempt to fetch the user's shareKey
			$shareKey = Keymanager::getShareKey( $view, $userId, $relPath );
			
			// Decrypt keyfile with shareKey
			$plainKeyfile = Crypt::multiKeyDecrypt( $encKeyfile, $shareKey, $privateKey );
		
			$plainData = Crypt::symmetricDecryptFileContent( $data, $plainKeyfile );

		} elseif (
		Crypt::mode() == 'server' 
		&& isset( $_SESSION['legacyenckey'] )
		&& Crypt::isEncryptedMeta( $path ) 
		) {
			
			$plainData = Crypt::legacyDecrypt( $data, $session->getLegacyKey() );
			
		}
		
		\OC_FileProxy::$enabled = $proxyStatus;
		
		if ( ! isset( $plainData ) ) {
		
			$plainData = $data;
			
		}
		
		return $plainData;
		
	}
	
	/**
	 * @brief When a file is deleted, remove its keyfile also
	 */
	public function preUnlink( $path ) {
	
		// let the trashbin handle this  
		if ( \OCP\App::isEnabled('files_trashbin') ) {
		     return true;
		}
		
		// Disable encryption proxy to prevent recursive calls
        $proxyStatus = \OC_FileProxy::$enabled;
        \OC_FileProxy::$enabled = false;
		
		$view = new \OC_FilesystemView( '/' );

		$userId = \OCP\USER::getUser();

		$util = new Util( $view, $userId );

		// Format path to be relative to user files dir
		$relPath = $util->stripUserFilesPath( $path );

 		list( $owner, $ownerPath ) = $util->getUidAndFilename( $relPath );

		// Delete keyfile & shareKey so it isn't orphaned
		if (
			! (
				Keymanager::deleteFileKey( $view, $owner, $ownerPath )
				&& Keymanager::delAllShareKeys( $view, $owner, $ownerPath )
			)
		) {
		
			\OC_Log::write( 'Encryption library', 'Keyfile or shareKey could not be deleted for file "'.$ownerPath.'"', \OC_Log::ERROR );
				
		}
		
		\OC_FileProxy::$enabled = $proxyStatus;
		
		// If we don't return true then file delete will fail; better
		// to leave orphaned keyfiles than to disallow file deletion
		return true;
	
	}

	/**
	 * @brief When a file is renamed, rename its keyfile also
	 * @return bool Result of rename()
	 * @note This is pre rather than post because using post didn't work
	 */
	public function preRename( $oldPath, $newPath )
    {

        // Disable encryption proxy to prevent recursive calls
        $proxyStatus = \OC_FileProxy::$enabled;
        \OC_FileProxy::$enabled = false;

        $view = new \OC_FilesystemView('/');

        $userId = \OCP\USER::getUser();

        // Format paths to be relative to user files dir
        $oldTrimmed = ltrim($oldPath, '/');
        $oldSplit = explode('/', $oldTrimmed);
        $oldSliced = array_slice($oldSplit, 2);
        $oldRelPath = implode('/', $oldSliced);
        $oldKeyfilePath = $userId . '/' . 'files_encryption' . '/' . 'keyfiles' . '/' . $oldRelPath;

        $newTrimmed = ltrim($newPath, '/');
        $newSplit = explode('/', $newTrimmed);
        $newSliced = array_slice($newSplit, 2);
        $newRelPath = implode('/', $newSliced);
        $newKeyfilePath = $userId . '/' . 'files_encryption' . '/' . 'keyfiles' . '/' . $newRelPath;

        // add key ext if this is not an folder
        if (!$view->is_dir($oldKeyfilePath)) {
            $oldKeyfilePath .= '.key';
            $newKeyfilePath .= '.key';

            // handle share-keys
            $localKeyPath = $view->getLocalFile($userId.'/files_encryption/share-keys/'.$oldRelPath);
            $matches = glob(preg_quote($localKeyPath).'*.shareKey');
            foreach ($matches as $src) {
                $dst = str_replace($oldRelPath, $newRelPath, $src);
                rename($src, $dst);
            }

        } else {
            // handle share-keys folders
            $oldShareKeyfilePath = $userId . '/' . 'files_encryption' . '/' . 'share-keys' . '/' . $oldRelPath;
            $newShareKeyfilePath = $userId . '/' . 'files_encryption' . '/' . 'share-keys' . '/' . $newRelPath;
            $view->rename($oldShareKeyfilePath, $newShareKeyfilePath);
        }

        // Rename keyfile so it isn't orphaned
        $result = $view->rename($oldKeyfilePath, $newKeyfilePath);

        \OC_FileProxy::$enabled = $proxyStatus;

        return $result;

    }

    /**
     * @brief When a file is renamed, rename its keyfile also
     * @return bool Result of rename()
     * @note This is pre rather than post because using post didn't work
     */
    public function postRename( $oldPath, $newPath )
    {

        // Disable encryption proxy to prevent recursive calls
        $proxyStatus = \OC_FileProxy::$enabled;
        \OC_FileProxy::$enabled = false;

        $view = new \OC_FilesystemView('/');
        $session = new Session($view);
        $userId = \OCP\User::getUser();
        $util = new Util( $view, $userId );

        // Reformat path for use with OC_FSV
        $newPathSplit = explode( '/', $newPath );
        $newPathRelative = implode( '/', array_slice( $newPathSplit, 3 ) );

        // get file info from database/cache
        //$newFileInfo = \OC\Files\Filesystem::getFileInfo($newPathRelative);

        if ($util->isEncryptedPath($newPath)) {
            $cached = $view->getFileInfo($newPath);
            $cached['encrypted'] = 1;

            // get the size from filesystem
            $size = $view->filesize($newPath);

            // calculate last chunk nr
            $lastChunckNr = floor($size / 8192);

            // open stream
            $result = fopen('crypt://' . $newPathRelative, "r");

            if(is_resource($result)) {
                // calculate last chunk position
                $lastChunckPos = ($lastChunckNr * 8192);

                // seek to end
                fseek($result, $lastChunckPos);

                // get the content of the last chunck
                $lastChunkContent = fread($result, 8192);

                // calc the real file size with the size of the last chunk
                $realSize = (($lastChunckNr * 6126) + strlen($lastChunkContent));

                // set the size
                $cached['unencrypted_size'] = $realSize;
            }

            $view->putFileInfo( $newPath, $cached );

            // get sharing app state
            $sharingEnabled = \OCP\Share::isEnabled();

            // get users
            $usersSharing = $util->getSharingUsersArray($sharingEnabled, $newPathRelative);

            // update sharing-keys
            $util->setSharedFileKeyfiles($session, $usersSharing, $newPathRelative);
        }


        \OC_FileProxy::$enabled = $proxyStatus;

        return true;

    }

    public function postFopen( $path, &$result ){

        if ( !$result ) {
		
			return $result;
			
		}

        // Reformat path for use with OC_FSV
		$path_split = explode( '/', $path );
		$path_f = implode( '/', array_slice( $path_split, 3 ) );

        // FIXME: handling for /userId/cache used by webdav for chunking. The cache chunks are NOT encrypted
        if($path_split[2] == 'cache') {
            return $result;
        }

		// Disable encryption proxy to prevent recursive calls
        $proxyStatus = \OC_FileProxy::$enabled;
        \OC_FileProxy::$enabled = false;

        $meta = stream_get_meta_data( $result );
		
		$view = new \OC_FilesystemView( '' );
		
		$util = new Util( $view, \OCP\USER::getUser());
		
		// If file is already encrypted, decrypt using crypto protocol
		if ( 
			Crypt::mode() == 'server' 
			&& $util->isEncryptedPath( $path ) 
		) {
			
			// Close the original encrypted file
			fclose( $result );
			
			// Open the file using the crypto stream wrapper 
			// protocol and let it do the decryption work instead
			$result = fopen( 'crypt://' . $path_f, $meta['mode'] );
			
			
		} elseif ( 
			self::shouldEncrypt( $path ) 
			and $meta ['mode'] != 'r' 
			and $meta['mode'] != 'rb' 
		) {
		// If the file is not yet encrypted, but should be 
		// encrypted when it's saved (it's not read only)
		
		// NOTE: this is the case for new files saved via WebDAV
		
//			if (
//			$view->file_exists( $path )
//			and $view->filesize( $path ) > 0
//			) {
//				$x = $view->file_get_contents( $path );
//
//				$tmp = tmpfile();
				
// 				// Make a temporary copy of the original file
// 				\OCP\Files::streamCopy( $result, $tmp );
// 				
// 				// Close the original stream, we'll return another one
// 				fclose( $result );
// 				
// 				$view->file_put_contents( $path_f, $tmp );
// 				
// 				fclose( $tmp );
			
//			}

            $result = fopen( 'crypt://'.$path_f, $meta['mode'] );
		
		}
		
		// Re-enable the proxy
		\OC_FileProxy::$enabled = $proxyStatus;
		
		return $result;
	
	}

	public function postGetMimeType( $path, $mime ) {

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

    public function postGetFileInfo( $path, $data ) {

        // if path is a folder do nothing
        if(is_array($data) && array_key_exists('size', $data)) {

            // Disable encryption proxy to prevent recursive calls
            $proxyStatus = \OC_FileProxy::$enabled;
            \OC_FileProxy::$enabled = false;

            // get file size
            $data['size'] = self::postFileSize($path, $data['size']);

            // Re-enable the proxy
            \OC_FileProxy::$enabled = $proxyStatus;
        }

        return $data;
    }

	public function postStat( $path, $data ) {

        if ( Crypt::isCatfileContent( $path ) ) {
		
			$cached = \OC\Files\Filesystem::getFileInfo( $path, '' );
			
			$data['size'] = $cached['unencrypted_size'];
			
		}
		
		return $data;
	}

	public function postFileSize( $path, $size ) {

        $view = new \OC_FilesystemView( '/' );

        // if path is a folder do nothing
        if($view->is_dir($path)) {
            return $size;
        }

        // Reformat path for use with OC_FSV
        $path_split = explode('/', $path);
        $path_f = implode('/', array_slice($path_split, 3));

        // get file info from database/cache
        $fileInfo = \OC\Files\Filesystem::getFileInfo($path_f);

        // if file is encrypted return real file size
        if(is_array($fileInfo) && $fileInfo['encrypted'] == 1) {
            return $fileInfo['unencrypted_size'];
        } else {
            return $size;
        }
	}
}