nextcloud/apps/files_encryption/lib/proxy.php

378 lines
9.1 KiB
PHP
Raw Normal View History

2011-10-21 19:02:11 +04:00
<?php
/**
* ownCloud
*
* @author Sam Tuke, Robin Appelman
* @copyright 2012 Sam Tuke samtuke@owncloud.com, Robin Appelman
* icewind1991@gmail.com
2011-10-21 19:02:11 +04:00
*
* 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/>.
*
*/
namespace OCA\Encryption;
class Proxy extends \OC_FileProxy {
private static $blackList = null; //mimetypes blacklisted from encryption
private static $enableEncryption = null;
2011-11-24 04:44:54 +04:00
/**
* Check if a file requires encryption
2011-11-24 04:44:54 +04:00
* @param string $path
* @return bool
*
* Tests if server side encryption is enabled, and file is allowed by blacklists
2011-11-24 04:44:54 +04:00
*/
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;
}
2012-04-18 18:02:35 +04:00
}
if ( !self::$enableEncryption ) {
2012-04-18 18:02:35 +04:00
return false;
2012-04-18 18:02:35 +04:00
}
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' ) );
2011-11-24 04:44:54 +04:00
}
if ( Crypt::isCatfile( $path ) ) {
2011-11-24 04:44:54 +04:00
return true;
2011-11-24 04:44:54 +04:00
}
$extension = substr( $path, strrpos( $path, '.' ) +1 );
if ( array_search( $extension, self::$blackList ) === false ) {
2011-11-24 04:44:54 +04:00
return true;
2011-11-24 04:44:54 +04:00
}
return false;
2011-11-24 04:44:54 +04:00
}
public function preFile_put_contents( $path, &$data ) {
if ( self::shouldEncrypt( $path ) ) {
2012-11-22 18:08:19 +04:00
if ( !is_resource( $data ) ) { //stream put contents should have been converted to fopen
$userId = \OCP\USER::getUser();
$rootView = new \OC_FilesystemView( '/' );
// Set the filesize for userland, before encrypting
$size = strlen( $data );
// Disable encryption proxy to prevent recursive calls
\OC_FileProxy::$enabled = false;
// TODO: Check if file is shared, if so, use multiKeyEncrypt
// Encrypt plain data and fetch key
$encrypted = Crypt::keyEncryptKeyfile( $data, Keymanager::getPublicKey( $rootView, $userId ) );
// 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( '/' );
// Save keyfile for newly encrypted file in parallel directory tree
Keymanager::setFileKey( $view, $filePath, $userId, $encrypted['key'] );
// 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;
2011-10-21 19:02:11 +04:00
}
}
2011-10-21 19:02:11 +04:00
}
/**
* @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 ) {
// TODO: Use dependency injection to add required args for view and user etc. to this method
// Disable encryption proxy to prevent recursive calls
\OC_FileProxy::$enabled = false;
// If data is a catfile
if (
Crypt::mode() == 'server'
&& Crypt::isCatfile( $data )
) {
$split = explode( '/', $path );
2012-11-23 00:19:03 +04:00
$filePath = array_slice( $split, 3 );
2012-11-23 00:19:03 +04:00
$filePath = '/' . implode( '/', $filePath );
//$cached = \OC_FileCache_Cached::get( $path, '' );
$view = new \OC_FilesystemView( '' );
$userId = \OCP\USER::getUser();
// TODO: Check if file is shared, if so, use multiKeyDecrypt
$encryptedKeyfile = Keymanager::getFileKey( $view, $userId, $filePath );
$session = new Session();
$decrypted = Crypt::keyDecryptKeyfile( $data, $encryptedKeyfile, $session->getPrivateKey( $split[1] ) );
} elseif (
Crypt::mode() == 'server'
&& isset( $_SESSION['legacyenckey'] )
&& Crypt::isEncryptedMeta( $path )
) {
$decrypted = Crypt::legacyDecrypt( $data, $_SESSION['legacyenckey'] );
2011-10-21 19:02:11 +04:00
}
\OC_FileProxy::$enabled = true;
if ( ! isset( $decrypted ) ) {
$decrypted = $data;
}
return $decrypted;
2011-10-21 19:02:11 +04:00
}
/**
* @brief When a file is deleted, remove its keyfile also
*/
public function postUnlink( $path ) {
// Disable encryption proxy to prevent recursive calls
\OC_FileProxy::$enabled = false;
$view = new \OC_FilesystemView( '/' );
$userId = \OCP\USER::getUser();
// Format path to be relative to user files dir
$trimmed = ltrim( $path, '/' );
$split = explode( '/', $trimmed );
$sliced = array_slice( $split, 2 );
$relPath = implode( '/', $sliced );
// Delete keyfile so it isn't orphaned
$result = Keymanager::deleteFileKey( $view, $userId, $relPath );
\OC_FileProxy::$enabled = true;
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 preRename( $oldPath, $newPath ) {
// trigger_error( "PATHS = ".var_export($oldPath, 1).' '.var_export($newPath, 1));
// Disable encryption proxy to prevent recursive calls
\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 . '.key';
$newTrimmed = ltrim( $newPath, '/' );
$newSplit = explode( '/', $newTrimmed );
$newSliced = array_slice( $newSplit, 2 );
$newRelPath = implode( '/', $newSliced );
$newKeyfilePath = $userId . '/' . 'files_encryption' . '/' . 'keyfiles' . '/' . $newRelPath . '.key';
// trigger_error("RENAMING = ".var_export($oldKeyfilePath, 1).' -> '.var_export($newKeyfilePath, 1));
// Rename keyfile so it isn't orphaned
$result = $view->rename( $oldKeyfilePath, $newKeyfilePath );
\OC_FileProxy::$enabled = true;
return $result;
}
public function postFopen( $path, &$result ){
2012-11-22 23:36:48 +04:00
if ( !$result ) {
2011-11-24 04:44:54 +04:00
return $result;
2011-11-24 04:44:54 +04:00
}
// Reformat path for use with OC_FSV
$path_split = explode( '/', $path );
$path_f = implode( array_slice( $path_split, 3 ) );
// Disable encryption proxy to prevent recursive calls
\OC_FileProxy::$enabled = false;
$meta = stream_get_meta_data( $result );
2012-11-22 18:08:19 +04:00
$view = new \OC_FilesystemView( '' );
$util = new Util( $view, \OCP\USER::getUser());
2012-11-22 23:36:48 +04:00
// If file is already encrypted, decrypt using crypto protocol
if (
Crypt::mode() == 'server'
&& $util->isEncryptedPath( $path )
) {
2012-11-22 23:36:48 +04:00
// 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'] );
2012-11-22 23:36:48 +04:00
2012-11-22 18:08:19 +04:00
} 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
2012-11-23 00:19:03 +04:00
if (
$view->file_exists( $path )
and $view->filesize( $path ) > 0
) {
$x = $view->file_get_contents( $path );
2012-11-23 00:19:03 +04:00
$tmp = tmpfile();
2012-11-23 00:19:03 +04:00
// // 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 );
2011-11-24 04:44:54 +04:00
}
2012-11-23 00:19:03 +04:00
$result = fopen( 'crypt://'.$path_f, $meta['mode'] );
2012-11-22 18:08:19 +04:00
}
2012-11-14 17:58:57 +04:00
// Re-enable the proxy
\OC_FileProxy::$enabled = true;
2011-11-24 04:44:54 +04:00
return $result;
2011-10-21 19:02:11 +04:00
}
2012-02-16 00:44:58 +04:00
public function postGetMimeType( $path, $mime ) {
if ( Crypt::isCatfile( $path ) ) {
$mime = \OCP\Files::getMimeType( 'crypt://' . $path, 'w' );
}
return $mime;
2012-02-16 00:44:58 +04:00
}
public function postStat( $path, $data ) {
if ( Crypt::isCatfile( $path ) ) {
$cached = \OC_FileCache_Cached::get( $path, '' );
$data['size'] = $cached['size'];
}
return $data;
}
public function postFileSize( $path, $size ) {
if ( Crypt::isCatfile( $path ) ) {
$cached = \OC_FileCache_Cached::get( $path, '' );
return $cached['size'];
} else {
return $size;
}
}
2011-10-21 19:02:11 +04:00
}