精华内容
下载资源
问答
  • 文件监控
    千次阅读
    2019-07-17 14:57:31

    https://github.com/dstmath/inotifywait-for-Android.git 工具来进行文件监控,它是利用linux下inotify机制对文件系统进行监控的,我们可以利用它来监控某款APP的文件操作行为,比起利用hook机制来监控文件系统.

    (1)

    git clone https://github.com/dstmath/inotifywait-for-Android.git  
    cd inotifywait-for-Android
    ndk-build
    
    [armeabi] Compile thumb  : inotifywait <= wrap_inotifywait.c
    [armeabi] Compile thumb  : inotifywait <= common.c
    [armeabi] Compile thumb  : inotifywait <= inotifytools.c
    In file included from jni/libinotifytools/inotifytools.c:31:0:
    jni/libinotifytools/../regex/regex.h:367:40: warning: declaration does not declare anything
       unsigned long int __REPB_PREFIX(used);
                                            ^
    [armeabi] Compile thumb  : inotifywait <= redblack.c
    [armeabi] Executable     : inotifywait
    [armeabi] Install        : inotifywait => libs/armeabi/inotifywait
    [armeabi] Compile thumb  : inotifywatch <= wrap_inotifywatch.c
    [armeabi] Compile thumb  : inotifywatch <= common.c
    [armeabi] Compile thumb  : inotifywatch <= inotifytools.c
    In file included from jni/libinotifytools/inotifytools.c:31:0:
    jni/libinotifytools/../regex/regex.h:367:40: warning: declaration does not declare anything
       unsigned long int __REPB_PREFIX(used);
                                            ^
    [armeabi] Compile thumb  : inotifywatch <= redblack.c
    [armeabi] Executable     : inotifywatch
    [armeabi] Install        : inotifywatch => libs/armeabi/inotifywatch

     

    (2)

    adb push inotifywatch /data/local/tmp/
    adb push inotifywait /data/local/tmp/
    adb shell
    su
    mount -o rw,remount /system
    cp /data/local/tmp/inotifywatch /system/xbin
    chmod 755 /system/xbin/inotivywatch
    cp /data/local/tmp/inotifywait /system/xbin
    chmod 755 /system/xbin/inotivywait

    (3)

    adb shell
    #查看帮助  
    inotifywait -h
    #监控/system目录
    inotifywait -r -m --timefmt %a-%b-%d-%T  --format '%e:------%w%f %T' /system

     

    inotifywait -r -m /data/data/com.xxxx.yyyy

     

     

    更多相关内容
  • 计算机文件监控.rar

    2020-03-28 23:45:14
    计算机文件监控.rar 计算机文件监控.rar 计算机文件监控.rar 计算机文件监控.rar 计算机文件监控.rar 计算机文件监控.rar
  • 可以简单的监控你的文件不被移动、修改和删除,用java实现,没有使用JNI的方式去调用,所以只是模拟了文件监控,还有很多的确定..
  • 文件监控——watchdog详解

    千次阅读 2020-11-10 20:18:14
    文件监控——watchdog详解 一、官方文档(需要细节选择去官网,需要了解和应用范例看本文即可) https://pythonhosted.org/watchdog/ User’s Guide 安装 快速开始 API 相关 贡献 二、watchdog...

    文件监控——watchdog详解

    一、官方文档(需要细节选择去官网,需要了解和应用范例看本文即可)

    https://pythonhosted.org/watchdog/
    官网上的:User’s Guide,主要看API相关这里即可

    1. 安装
    2. 快速开始
    3. API 相关

    二、watchdog安装

    watchdog需要在python2.6以上的版本工作,如果使用的是Linux//FreeBSD/Mac OS X 系统,python已经安装了,但是需要保证python的版本至少是python2.7(学习用最好还是使用3.6以上的版本吧)
    下面有三种不同的安装方法:选择第一种最简单的就行了,可以简便的不要自求麻烦。

    1. Installing from PyPI using pip

    pip install watchdog
    

    2. Installing from source tarballs

    $ wget -c http://pypi.python.org/packages/source/w/watchdog/watchdog-0.8.2.tar.gz
    $ tar zxvf watchdog-0.8.2.tar.gz
    $ cd watchdog-0.8.2
    $ python setup.py install
    

    3. Installing from the code repository

    $ git clone --recursive git://github.com/gorakhargosh/watchdog.git
    $ cd watchdog
    $ python setup.py install
    

    在官方还说需要下载一些依赖,但是你使用第一种pip安装的方法基本都不会有这种需求。

    三、快速开始(官方范例)

    下面我们提供一个简单的示例,该示例以递归方式监视当前目录(这意味着它将遍历所有子目录)以检测更改。 这是我们将要使用的API:

    1. 创建watchdog.observers.Observer线程类的实例
    2. 实现watchdog.events.FileSystemEventHandler的子类(或者在我们的例子中,我们将使用内置的watchdog.events.LoggingEventHandler)。
    3. 通过附加事件处理程序的观察者实例来计划监视一些路径。
    4. 启动观察者线程并等待它生成事件而不会阻塞我们的主线程。
    import sys
    import time
    import logging
    from watchdog.observers import Observer # 监控
    from watchdog.events import LoggingEventHandler # 触发事件
    
    if __name__=='__main__':
        logging.basicConfig(level=logging.INFO,
                            format='%(asctime)s - %(message)s',
                            datefmt='%Y-%m-%d %H:%M:%S')
        path = sys.argv[1] if len(sys.argv) > 1 else '.'
        event_handler = LoggingEventHandler() # 监控处理事件的方法,这个类非常重要,可以根据自己的需要重写
        observer = Observer() # 定义监控类,多线程类 thread class
        observer.schedule(event_handler,'./monitor_folder_1', recursive=True) # 指定监控路径/触发对应的监控事件类
        observer.start()# 将observer运行在同一个线程之内,不阻塞主进程运行,可以调度observer来停止该线程
        try:
            while True:
                time.sleep(1) # 监控频率(1s1次,根据自己的需求进行监控)
        except KeyboardInterrupt:
            observer.stop()
        observer.join()
    

    四、API Reference(翻译官网)

    观察者模型主要有三个角色:observer、event_handler、被监控的文件夹。三者原本是独立的,主要通过observer.schedule函数将三者串起来,意思为observer不断检测调用平台依赖代码对监控文件夹进行变动检测,当发现改变时,通知event_handler处理。
    watchdog.event
    模型:watchdog.events
    简介:文件系统事件和时间处理的程序
    原作者: yesudeep@google.com (Yesudeep Mangalapilly)

    1. Event Class

    首先考虑一下关于文件和文件夹的相关操作有那些?
    无外乎:

    • 创建(FileCreatedEvent/DirCreateEvent)
    • 移动(FileMovedEvent/DirMovedEvent)
    • 删除(FildDeletedEvent/DirDeletedEvent)
    • 修改(FileModifiedEvent/DirModifiedEvent)

    对文件/文件夹的监控也就无非以上的操作了,watchdog对文件夹的监控也就是针对上述需求进行设计的
    Event Classes也就包含了大概八个类(都分别依赖于watchdog.events.FileSystemEvent 和watchdog.events.FileSystemMovedEvent):

    • class watchdog.events.FileMovedEvent(src_path, dest_path)
    • class watchdog.events.DirMovedEvent(src_path, dest_path)
    • class watchdog.events.FileModifiedEvent(src_path)
    • class watchdog.events.DirModifiedEvent(src_path)
    • class watchdog.events.FileCreatedEvent(src_path)
    • class watchdog.events.DirCreatedEvent(src_path)
    • class watchdog.events.FileDeletedEvent(src_path)
    • class watchdog.events.DirDeletedEvent(src_path)

    2. Event handler Classes事件处理类

    官方文件中对Event Handler Classes的说明:
    class watchdog.events.FileSystemEventHandler[source]
    	Bases: object
    	Base file system event handler that you can override methods from.
    	
    	dispatch(event)[source]
    	Dispatches events to the appropriate methods.
    	Parameters:	event (FileSystemEvent) – The event object representing the file system event.
    	
    	on_any_event(event)[source]
    	Catch-all event handler.
    	Parameters:	event (FileSystemEvent) – The event object representing the file system event.
    	
    	on_created(event)[source]
    	Called when a file or directory is created.
    	Parameters:	event (DirCreatedEvent or FileCreatedEvent) – Event representing file/directory creation.
    	
    	on_deleted(event)[source]
    	Called when a file or directory is deleted.
    	Parameters:	event (DirDeletedEvent or FileDeletedEvent) – Event representing file/directory deletion.
    	
    	on_modified(event)[source]
    	Called when a file or directory is modified.
    	Parameters:	event (DirModifiedEvent or FileModifiedEvent) – Event representing file/directory modification.
    	
    	on_moved(event)[source]
    	Called when a file or a directory is moved or renamed.
    	Parameters:	event (DirMovedEvent or FileMovedEvent) – Event representing file/directory movement.
    

    上述也就说明了watchdog的触发事件的方法为:

    • dispatch
    • on_any_event
    • on_create
    • on_delete
    • on_modified
    • on_moved

    对应到

    3. watchdog.observers.api

    class watchdog.observers.api.ObservedWatch(path, recursive)
    Bases: object
    An scheduled watch.
    Parameters:	
    	path – Path string.
    	recursive:
    		True if watch is recursive; 
    		False
    		otherwise.is_recursive:Determines whether subdirectories are watched for the path.
    path:The path that this watch monitors
    

    Observer用以监控文件的变化,根据触发事件调用相关联的事件处理方法来执行。

    observer是threading.Thread的子类,通过observer.start()使之运行在一个线程之中,不阻塞主线程的运行,然后可以调用observer.stop()来停止该进程.

    observer.schedule(event_handler,path,recursive=False)
    # event_handler:触发事件的操作方法
    # path:监控的文件或者目录
    # recursive:如果监控的是文件则需要设置为True
    

    五、linux中使用watchdog监控文件夹各种操作会触发的监控事件

    1. 移除文件:

    1. 文件删除:File_deleted
    2. 文件夹修改 Directory_modified

    2. 添加文件:

    1. 文件新建:File_created
    2. 文件夹修改:Directory_modified

    3.修改文件:

    1. 两次文件修改:File_modified(显示针对一个备份文件,然后是针对原始文件)
    2. 删除备份文件:File_deleted
    3. 文件夹修改:Directory_modified

    4.文件改名:

    1. 文件移动:File_moved
    2. 文件夹修改:Directory_modified

    5.使用cp命令复制文件到监控目录:

    1. 文件新建:File_created
    2. 一大堆文件修改操作:Directory_modified
    3. 文件夹修改操作:File_modified

    六、应用实例

    1.监控文件夹中是否有后缀为".segy"的文件进入

    #! /home/liufeng/project
    # -*- coding:utf-8 -*-
    # Created by jerry_liufeng
    
    # 本模块的功能:<检测文件夹变化>
    
    # 导入watchdog对应模块
    from watchdog.observers import Observer
    from watchdog.events import *
    # 导入时间模块
    import time
    
    class FileEventHandler(FileSystemEventHandler):
        # 初始化魔术方法
        def __init__(self):
            FileSystemEventHandler.__init__(self)
            self.fileNameList = [] # 文件名列表(存储文件名)
    
        # 文件或文件夹移动
        def on_moved(self, event):
            if event.is_directory:
                print("directory moved from {0} to {1}".format(event.src_path,event.dest_path))
            else:
                print("file moved from {0} to {1}".format(event.src_path,event.dest_path))
    
        # 创建文件或文件夹
        def on_created(self, event):
            if event.is_directory:
                print("directory created:{0}".format(event.src_path))
            else:
                print("file created:{0}".format(event.src_path))
                fileAllName =str(event.src_path.split('/')[-1])
                if fileAllName.endswith('.segy'):
                    self.fileNameList.append(fileAllName)
                print(self.fileNameList)
                    
        # 删除文件或文件夹
        def on_deleted(self, event):
            if event.is_directory:
                print("directory deleted:{0}".format(event.src_path))
            else:
                print("file deleted:{0}".format(event.src_path))
    
    #     # 修改文件或文件夹
    #     def on_modified(self, event):
    #         if event.is_directory:
    #             print("directory modified:{0}".format(event.src_path))
    #         else:
    #             print("file modified:{0}".format(event.src_path))
    
    if __name__ == "__main__":
        # 实例化Observer对象
        observer = Observer()
        event_handler = FileEventHandler()
        # 设置监听目录
        dis_dir = "./03_seis_data/"
        observer.schedule(event_handler,dis_dir,True)
        observer.start()
        try:
            while True:
                # 设置监听频率(间隔周期时间)
                time.sleep(1)
        except KeyboardInterrupt:
            observer.stop()
        observer.join()
    
    

    说明:之所以注释掉modified这段代码是因为我关心的是文件的进入,而非文件内容的改变,太过频繁的modified操作会影响我对新增文件数量的判断。

    2.监控多个文件夹

    from watchdog.observers import Observer
    from watchdog.events import FileSystemEventHandler
    import time
    
    class FileEventHandler(FileSystemEventHandler):
        def __init__(self):
            FileSystemEventHandler.__init__(self)
     
        def on_moved(self, event):
            if event.is_directory:
                print("directory moved from {0} to {1}".format(event.src_path,event.dest_path))
            else:
                print("file moved from {0} to {1}".format(event.src_path,event.dest_path))
     
        def on_created(self, event):
            if event.is_directory:
                print("directory created:{0}".format(event.src_path))
            else:
                print("file created:{0}".format(event.src_path))
     
        def on_deleted(self, event):
            if event.is_directory:
                print("directory deleted:{0}".format(event.src_path))
            else:
                print("file deleted:{0}".format(event.src_path))
     
        def on_modified(self, event):
            if event.is_directory:
                print("directory modified:{0}".format(event.src_path))
            else:
                print("file modified:{0}".format(event.src_path))
    
    if __name__ == "__main__":
        observer = Observer()
        dirs = [r'./monitor_folder_1', r'./monitor_folder_1']
    #    dirs = [ r'./monitor_folder_1']
        for dir in dirs:
            event_handler = FileEventHandler()
            observer.schedule(event_handler, dir, True)
        observer.start()
    

    3.文件系统一次操作多次触发各类事件问题解决:

    原文参考:https://blog.csdn.net/xufive/article/details/93847372
    问题:
    文件操作引发的事件比我们想象的多了不少,而且难以在事件函数中做出针对性处理。

    在 windows 平台上每一次的文件修改引发两次 modified 事件?在 windows 平台上,由于 watchdog 封装的是 windows 系统的 FileSystemWatcher Events,处理文件的过程中执行了多次文件系统操作,无法避免地触发了多次事件。

    改进方案:
    如果对监视文件的实时性要求不高,又懒得处理一大堆事件,那么,比较事件前后的文件夹快照就是一个值得尝试的改进方案。实现这个思路,有三个前提条件:

    • 快速获取文件夹快照。幸运的是,watchdog 模块为我们提供了 DirectorySnapshot 功能
    • 可以接受200毫秒的延时。文件操作引发的一大堆事件会集中在一个较短的时间内,一般情况下,在文件操作之后200毫秒获取文件夹快照,是一个不错的间隔
    • 快速比较文件夹快照。这也不是问题,watchdog 模块有 DirectorySnapshotDiff 子模块

    改进思路:设置一个定时器, 200毫秒后抓取快照,并与上一张快照比较。每当有事件发生时,检查定时器是否已经启动。如果未启动,则直接启动定时器;否则,说明该事件距离上次事件不足200毫秒,可视为是同一组事件,此时终止定时器,再次重启。具体代码如下:

    import time
    import os, threading
    from watchdog.observers import Observer
    from watchdog.events import *
    from watchdog.utils.dirsnapshot import DirectorySnapshot, DirectorySnapshotDiff
    
    class FileEventHandler(FileSystemEventHandler):
        def __init__(self, aim_path):
            FileSystemEventHandler.__init__(self)
            self.aim_path = aim_path
            self.timer = None
            self.snapshot = DirectorySnapshot(self.aim_path)
        
        def on_any_event(self, event):
            if self.timer:
                self.timer.cancel()
            
            self.timer = threading.Timer(0.2, self.checkSnapshot)
            self.timer.start()
        
        def checkSnapshot(self):
            snapshot = DirectorySnapshot(self.aim_path)
            diff = DirectorySnapshotDiff(self.snapshot, snapshot)
            self.snapshot = snapshot
            self.timer = None
            
            print("files_created:", diff.files_created)
            print("files_deleted:", diff.files_deleted)
            print("files_modified:", diff.files_modified)
            print("files_moved:", diff.files_moved)
            print("dirs_modified:", diff.dirs_modified)
            print("dirs_moved:", diff.dirs_moved)
            print("dirs_deleted:", diff.dirs_deleted)
            print("dirs_created:", diff.dirs_created)
        
    #     def on_moved(self, event):
    #         if event.is_directory:
    #             print("directory moved from {0} to {1}".format(event.src_path,event.dest_path))
    #         else:
    #             print("file moved from {0} to {1}".format(event.src_path,event.dest_path))
     
    #     def on_created(self, event):
    #         if event.is_directory:
    #             print("directory created:{0}".format(event.src_path))
    #         else:
    #             print("file created:{0}".format(event.src_path))
     
    #     def on_deleted(self, event):
    #         if event.is_directory:
    #             print("directory deleted:{0}".format(event.src_path))
    #         else:
    #             print("file deleted:{0}".format(event.src_path))
     
    #     def on_modified(self, event):
    #         if event.is_directory:
    #             print("directory modified:{0}".format(event.src_path))
    #         else:
    #             print("file modified:{0}".format(event.src_path))
    
    
    class DirMonitor(object):
        """文件夹监视类"""
        
        def __init__(self, aim_path):
            """构造函数"""
            self.aim_path= aim_path
            self.observer = Observer()
        
        def start(self):
            """启动"""
            event_handler = FileEventHandler(self.aim_path)
            self.observer.schedule(event_handler, self.aim_path, True)
            self.observer.start()
        
        def stop(self):
            """停止"""
            self.observer.stop()
        
    if __name__ == "__main__": 
        monitor = DirMonitor(r"./monitor_folder_1") 
        monitor.start() 
        try: 
            while True: 
                time.sleep(1) 
        except KeyboardInterrupt: 
            monitor.stop() 
    

    代码评价:可以使用,问题得到了很好的解决,但是个人感觉触发的事件还是太多了,我们很多时候仅仅需要这个解决方案中的一部分功能而已,所以可以根据博主的思路进行一定的代码重构和更改。

    展开全文
  • 文件操作监控.zip

    2019-06-11 13:58:38
    文件监控工具,最新版本,不错,分享给大家,文件监控工具,最新版本,不错,分享给大家
  • 监视文件夹里面的文件的创建、修改、删除、重命名。支持对特定文件类型进行监视。
  • Hook实现文件监控

    千次阅读 2018-11-29 14:44:07
    该Windows文件监控系统旨在为Windows环境中的文件提供安全性。我需要设计一个应用程序来监视Windows上的文件打开、关闭和保存操作,并限制用户在安装此实用程序之前访问文件类型的子集。这是通过连接Windows文件相关...
    • 介绍

    该Windows文件监控系统旨在为Windows环境中的文件提供安全性。我需要设计一个应用程序来监视Windows上的文件打开、关闭和保存操作,并限制用户在安装此实用程序之前访问文件类型的子集。这是通过连接Windows文件相关api,然后根据需要在Windows中对文件进行打开、保存和关闭操作的预处理来实现的。预处理可能是对文件进行加密,破坏文件的标题部分等。如果在系统上安装了这个实用程序,那么文件(最初是加密的格式)在打开之前首先解密,然后在关闭或保存文件时再次加密。这将有助于防止在未安装此实用程序的任何其他地方访问该文件,从而为该文件提供安全性。

    我发现一些很好的应用程序,如AvaFind、FileMon等,可以执行文件监控功能。但是,这些应用程序使用系统驱动程序来实现它们的目标。由于编写驱动程序涉及的复杂性,我试图通过Win32用户级编程实现同样的目标。我通过连接kernel32.dll的CreateProcess()、OpenProcess()、CreateFile()、CloseHandle()和WriteFile()函数实现了这一点。

    在挂钩Windows api的各种可用方法中,我选择了“通过更改系统上运行的所有进程的导入地址表(Import Address Table, IAT)来挂钩”的方法。通过使用Windows API CreateRemoteThread()在目标进程的地址空间中创建远程线程,将包含更改IAT代码的DLL注入目标进程的地址空间(DLL将被注入的进程)。

    Jeffrey Richter的文章“使用INJLIB将32位DLL加载到另一个进程的地址空间”很好地记录了远程线程注入DLL。到目前为止,注入DLL一直是使用最广泛的概念,一旦DLL位于其地址空间内,注入DLL的最大优点是可以控制进程。但是,这种方法有一个缺点,在kernel32的情况下DLL没有被注入到目标进程中。dll不会在其众所周知的首选加载地址加载。因此,注入DLL的方法是基于唯一的假设,即Kernel32的加载地址。dll对这两个进程保持相同。

    • 设计和实现

    回到最初的问题……

    我执行的第一步是创建HookAPI。dll,其中包含挂钩Windows api的代码,然后将该dll注入到系统上所有运行的进程中。一旦注入目标进程,HookAPI。dll改变进程的IAT及其所有加载模块。HookAPI。dll包含一个名为GetIAList()的函数,该函数遍历注入它的进程的IAT。它使用EnumProcessModules()获取注入它的进程的所有模块的列表。然后,它检查要挂起哪个函数,并将其在IAT中的地址替换为为该API提供的包装器函数的地址。GetNewAddress()函数遍历指定要挂起的函数的列表,并返回为要挂起的函数提供的包装器函数的地址。

    以下是替换周期的逻辑步骤:

    从进程DLL模块加载的每个进程的IAT中找到import部分,以及进程本身。

    找到导出该函数的DLL的IMAGE_IMPORT_DESCRIPTOR块。

    找到保存导入函数的原始地址的IMAGE_THUNK_DATA。

    将函数地址替换为包装器函数的地址。

    void GetIAList()
    {
        HMODULE hMods[1024];
        TCHAR szLibFile[MAX_PATH];
        HANDLE hProcess = GetCurrentProcess();
        HMODULE hModule = GetModuleHandle(TEXT("HookAPI.dll"));
        GetModuleFileName(hModule,szLibFile,sizeof(szLibFile));
        DWORD cbNeeded = 0;
        multimap <CString,void*> m_mapOld;
        multimap <CString,void*> :: iterator m_AcIter;
        PROC pfnNewAddress = NULL;
        unsigned int i = 0;
        PROC* ppfn = NULL;
        CString  str;
        ULONG ulSize = 0;
        if( EnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded))
        {
            for ( i = 0; i < (cbNeeded / sizeof(HMODULE)); i++ )
            {
                TCHAR szModName[MAX_PATH];
                // Get the full path to the module's file.
                if ( GetModuleFileNameEx( hProcess, hMods[i], 
                                          szModName, sizeof(szModName)))
                {
                    // We must skip the IAT of HookAPI.dll
                    // from being modified as it contains
                    // the wrapper functions for Windows AOIs being hooked.
                    if(_tcscmp(szModName,szLibFile) == 0)
                    {
                        i++;
                    }
                }
                // 获取模块文件的完整路径。
                PIMAGE_IMPORT_DESCRIPTOR pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)
                ImageDirectoryEntryToData(hMods[i], TRUE, 
                        IMAGE_DIRECTORY_ENTRY_IMPORT, &ulSize);
                if(NULL != pImportDesc)
                {
                    while (pImportDesc->Name)
                    {
                        PSTR pszModName = (PSTR)((PBYTE) hMods[i] + pImportDesc->Name);
                        CString  strModName = pszModName;
                        // 调用者的IAT
                        PIMAGE_THUNK_DATA pThunk = (PIMAGE_THUNK_DATA)
                                    ( (PBYTE) hMods[i] + pImportDesc->FirstThunk );
                        while (pThunk->u1.AddressOfData)
                        {
                            // 获取函数地址的地址
                            ppfn = (PROC*) &pThunk->u1.AddressOfData;
                            str.Format(_T("%s:%x"),strModName,*ppfn);
                            // 从IAT存储函数的dll名称和地址
                            // into a map in the form ("KERNEL32.dll:<address of CreateFile>",
                            // <address that contains the address of CreateFile in IAT>).
                            // The map contains the entries in the form
                            // ("KERNEL32.dll:0x110023",0x707462)
                            // ("KERNEL32.dll:0x110045",0x707234)
                            // ("KERNEL32.dll:0x110074",0x402462)
                            // ...
                            m_mapOld.insert( func_Pair( str, ppfn ) );
                            pThunk++;
                        }
                        pImportDesc++;
                    }
                }
            }
        }
            
        // Traverse the map to hook the appropriate function.
        for(m_AcIter = m_mapOld.begin() ; m_AcIter != m_mapOld.end() ; m_AcIter++)
        {
            // pfnNewAddress = GetNewAddress(m_AcIter -> first);
            // m_AcIter -> first is a string that gives all the informatino 
            // about the Windows API to be hooked like the name of the DLL 
            // in which the function is actually present, its address in that DLL 
            // and its address in IAT. 
            // GetNewAddress should be implemented in such a way that it should return 
            // the address of the wrapper function for Windows API implemented in HookAPI.dll
            if(pfnNewAddress != NULL)
            {
                PROC* pfnOldAddress = (PROC*)m_AcIter -> second;
               
                MEMORY_BASIC_INFORMATION mbi = {0};
                VirtualQuery( pfnOldAddress, &mbi, sizeof(MEMORY_BASIC_INFORMATION) );
                VirtualProtect( mbi.BaseAddress,mbi.RegionSize,PAGE_EXECUTE_READWRITE,
                                &mbi.Protect);
                
                // Replace the origional address of API with the address of corresponding 
                // wrapper function 
                *pfnOldAddress = *pfnNewAddress;
    
                DWORD dwOldProtect = 0;
                VirtualProtect( mbi.BaseAddress, mbi.RegionSize, mbi.Protect, &dwOldProtect );
      
            }
        }
    }

    设计好DLL之后,下一个任务是创建注入器。它注入挂钩DLL,挂钩api。dll,在所有运行的进程中,通过使用CreateRemoteThread(),如下所示。InjectIntoExistingProcesses()是在所有正在运行的进程中注入DLL的函数。它使用EnumProcesses()获取所有正在运行的进程的列表。这里,pszLibFile包含需要注入的DLL的路径,它只是钩子. DLL的路径。

    // Get the path of DLL to be injected
    TCHAR pszLibFile[MAX_PATH];
    GetModuleFileName(NULL,pszLibFile,sizeof(szLibFile));
    _tcscpy(_tcsrchr(pszLibFile,TEXT('\\')) + 1,TEXT("HookAPI.dll"));

    VirtualAllocEx()用于在加载DLL的远程进程的地址空间中分配内存。WriteProcessMemory()用于在分配的内存空间中写入DLL路径。GetProcAddress()给出了LoadLibrary() API的地址(假设内核32的加载地址)。然后CreateRemoteThread()最终在远程进程中创建一个线程,并将dll加载到远程进程的地址空间中。

    void InjectIntoExistingProcesses(PCWSTR pszLibFile)
    {
        BOOL fOk=FALSE;
        PWSTR pszLibFileRemote = NULL;
        
        int cch = 1+lstrlenW(pszLibFile);
        int cb = (cch + sizeof(WCHAR))*sizeof(WCHAR);
    
        DWORD aProcesses[1024], cbNeeded, cProcesses;    
        EnumProcesses( aProcesses, sizeof(aProcesses), &cbNeeded); 
        cProcesses = cbNeeded / sizeof(DWORD);
    
        // Get process handle for each running process. 
        for (int i = 0; i < cProcesses; i++)
        {
              HANDLE hRunningProcess = 
                OpenProcess( PROCESS_ALL_ACCESS,FALSE, aProcesses[i] );
              pszLibFileRemote = (PWSTR)VirtualAllocEx(hCurrentProcess,NULL,cb,
                            MEM_COMMIT,PAGE_READWRITE);
              SIZE_T nBytes = 0;
              WriteProcessMemory(hCurrentProcess, 
              pszLibFileRemote,(PVOID) pszLibFile,cb,&nBytes );
              LPTHREAD_START_ROUTINE pfnThreadRtn = ( LPTHREAD_START_ROUTINE ) 
              GetProcAddress(GetModuleHandle(TEXT("Kernel32")), 
                                                  "LoadLibraryW");
        
              CreateRemoteThread(hCurrentProcess,NULL,0, 
                  pfnThreadRtn,pszLibFileRemote,0,NULL);
              
              if (pszLibFileRemote != NULL)
              {
                 VirtualFreeEx(hCurrentProcess,pszLibFileRemote,0,MEM_RELEASE);
              }
              
              if (hRunningProcess != NULL)
              {
                 CloseHandle(hRunningProcess );
              }    
        }
    }

    当HookAPI.dll挂起所有正在运行的进程的CreateProcess()、OpenProcess()、CreateFile()、CloseHandle()和WriteFile()函数,我们在包装器函数中获得对在系统上完成的几乎所有文件操作的控制。CreateProcess()和OpenProcess()通过一个正在运行的进程来捕获任何新进程的创建,然后是HookAPI.dll再次通过分别为CreateProcess()和OpenProcess()提供的包装器函数注入到新创建的进程中。这样做是为了在任何新进程开始之前将DLL注入到每个新创建的进程中。将CreateFile()、close handle()和WriteFile()函数挂起,以便分别嗅出任何正在运行的进程和新创建的进程中的文件打开、关闭和写入操作。然后,可以根据需要修改为挂钩函数(如CreateFile()、CloseHandle()和WriteFile())提供的包装器函数,以便对文件操作进行预处理。

    • 此实用程序的第一次运行出现问题

    最初,系统上的所有文件既不是加密的格式,也不是解密的格式。该实用程序要求系统上所有相关文件(属于文件类型的特定子集的文件)在打开之前都应该以加密的形式存在。因此,这种加密应该在安装此实用程序时完成。一种方法是检查文件中是否存在这种噪声模式,以防定义了一种特定的噪声模式来损坏文件头。如有,应清除噪音,即,然后以上述方式解密该文件。如果没有,则表明这是第一次运行,不需要预处理。另一种方法是查找系统上属于实用程序要处理的文件类型的特定子集的所有文件,并在安装该实用程序时对它们进行加密。

    转自:https://www.codeproject.com/Articles/30537/%2fArticles%2f30537%2fWindows-File-Monitoring-System-Using-Windows-API-H

     

     

    展开全文
  • c++实现文件监控

    千次阅读 2020-10-05 08:46:00
    c++实现文件监控 #include "stdafx.h" #include "MonitorFile.h" void ShowError(char *pszText) { char szErr[MAX_PATH] = { 0 }; ::wsprintf(szErr, "%s Error[%d]\n", pszText, ::GetLastError()); ::...

    c++实现文件监控

    #include "stdafx.h"
    #include "MonitorFile.h"
    
    
    void ShowError(char *pszText)
    {
    	char szErr[MAX_PATH] = { 0 };
    	::wsprintf(szErr, "%s Error[%d]\n", pszText, ::GetLastError());
    	::MessageBox(NULL, szErr, "ERROR", MB_OK | MB_ICONERROR);
    }
    
    
    // 宽字节字符串转多字节字符串
    void W2C(wchar_t *pwszSrc, int iSrcLen, char *pszDest, int iDestLen)
    {
    	::RtlZeroMemory(pszDest, iDestLen);
    	// 宽字节字符串转多字节字符串
    	::WideCharToMultiByte(CP_ACP,
    		0,
    		pwszSrc,
    		(iSrcLen / 2),
    		pszDest,
    		iDestLen,
    		NULL,
    		NULL);
    }
    
    
    // 目录监控多线程
    UINT MonitorFileThreadProc(LPVOID lpVoid)
    {
    	char *pszDirectory = (char *)lpVoid;
    
    	// 打开目录, 获取文件句柄
    	HANDLE hDirectory = ::CreateFile(pszDirectory, FILE_LIST_DIRECTORY,
    		FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
    		FILE_FLAG_BACKUP_SEMANTICS, NULL);
    	if (INVALID_HANDLE_VALUE == hDirectory)
    	{
    		ShowError("CreateFile");
    		return 1;
    	}
    
    	char szTemp[MAX_PATH] = { 0 };
    	BOOL bRet = FALSE;
    	DWORD dwRet = 0;
    	DWORD dwBufferSize = 2048;
    	
    	// 申请一个足够大的缓冲区 
    	BYTE *pBuf = new BYTE[dwBufferSize];
    	if (NULL == pBuf)
    	{
    		ShowError("new");
    		return 2;
    	}
    	FILE_NOTIFY_INFORMATION *pFileNotifyInfo = (FILE_NOTIFY_INFORMATION *)pBuf;
    
    	// 开始循环设置监控
    	do
    	{
    		::RtlZeroMemory(pFileNotifyInfo, dwBufferSize);
    		// 设置监控目录
    		bRet = ::ReadDirectoryChangesW(hDirectory,
    			pFileNotifyInfo,
    			dwBufferSize,
    			TRUE,
    			FILE_NOTIFY_CHANGE_FILE_NAME |			// 修改文件名
    			FILE_NOTIFY_CHANGE_ATTRIBUTES |			// 修改文件属性
    			FILE_NOTIFY_CHANGE_LAST_WRITE,			// 最后一次写入
    			&dwRet,
    			NULL,
    			NULL);
    		if (FALSE == bRet)
    		{
    			ShowError("ReadDirectoryChangesW");
    			break;
    		}
    		// 将宽字符转换成窄字符
    		W2C((wchar_t *)(&pFileNotifyInfo->FileName), pFileNotifyInfo->FileNameLength, szTemp, MAX_PATH);
    		// 判断操作类型并显示
    		switch (pFileNotifyInfo->Action)
    		{
    		case FILE_ACTION_ADDED:
    		{
    			// 新增文件
    			printf("[File Added Action]%s\n", szTemp);
    			break;
    		}
    		default:
    		{
    			break;
    		}
    		}
    
    
    	} while (bRet);
    	// 关闭句柄, 释放内存
    	::CloseHandle(hDirectory);
    	delete[] pBuf;
    	pBuf = NULL;
    
    	return 0;
    }
    
    
    // 创建目录监控多线程
    void MonitorFile(char *pszDirectory)
    {
    	// 创建文件监控多线程
    	::CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)MonitorFileThreadProc, pszDirectory, 0, NULL);
    }
    int _tmain(int argc, _TCHAR* argv[])
    {
    	// 注意目录路径的末尾要加上反斜杠'\'
    	MonitorFile("C:\\Users\\Administrator\\Desktop\\1\\");
    
    	printf("monitor...\n");
    	getchar();
    	return 0;
    }
    
    展开全文
  • app文件行为监控!!
  • 文件监控 文件监控 文件监控 文件监控 文件监控 文件监控 文件监控
  • 二、C#中的文件监控 可以用钩子函数来处理,这种会处理得让你抓狂,一可能是太多消息事件,你头都大,二估计你不是C/C++的程序员,对win32函数本身就不熟,找资料都要你老费劲了。 那么C#中的文件监控还有什么办法...
  • C# FileSystemWatcher文件监控

    千次阅读 2019-04-08 15:54:00
    C#为我们提供了一个文件监控类(FileSystemWatcher),它定义了几个文件操作的事件,当我们对文件操作时便会引起这些事件,通过订阅这些事件,并添加自己的处理程序可实现对文件的监控。 FileSystemWatcher的属性 ...
  • Linux系统中的文件监控

    千次阅读 2019-02-28 13:36:02
    特定文件正在被那些进程操作 特定进程正在操作那些文件 实时监控特定文件一段时间 特定进程在执行过程中会操作哪些文件
  • java文件监控例子

    热门讨论 2011-01-09 16:38:48
    文件监控例子http://www.blogjava.net/pengo/archive/2011/01/09/342622.html的附件源码
  • 易语言监控文件模块

    2020-07-15 23:33:30
    易语言监控文件模块源码,监控文件模块
  • linux下c++实现文件监控

    千次阅读 2017-08-18 22:24:28
    linux下文件监控
  • Linux下使用inotify实现文件监控

    千次阅读 2017-12-07 22:49:21
    工程中需要对某个文件夹下的文件进行监控文件、目录发生变化后需要进行处理; 普通的方法是通过循环不停遍历文件夹,但文件数量较多时,将导致判定时间较长,并且无法区分文件使用正在使用; Linux2.6后提供了一种...
  • spring boot +commons-io实现文件监控

    千次阅读 2017-12-19 08:49:30
    1、pom文件 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://mave
  • JAVA 文件监控 WatchService

    千次阅读 2017-12-04 11:56:00
    监控是基于操作系统的文件系统监控器,可以监控系统是所有文件的变化,这种监控是无需遍历、无需比较的,是一种基于信号收发的监控,因此效率一定是最高的;现在Java对其进行了包装,可以直接在Java程序中使用OS的...
  • 使用2005 C#编写的文件监控程序 内含皮肤
  • java编写的ftp文件实时监控下载上传

    热门讨论 2016-03-22 17:06:13
    用java语言编写的ftp小工具,可以按指定时间监控ftp服务器,把服务器指定目录内新产生的文件或者文件夹下载到本地指定文件夹,下载后删除数据。 也可以监控本地文件夹,把文件夹内新产生的文件或者文件夹整体上传到...
  • 搜索了很多的网站,下面这个链接对我的帮最大,而且还有附带源码,自己记录一下,顺带分享给大家。 https://qualapps.blogspot.com/2010/05/understanding-readdirectorychangesw.html    ...
  • C# FileEventWatcher文件监控源代码

    千次下载 热门讨论 2012-12-21 10:49:50
    用C#做的一个FileWatcher文件监控程序的源代码,希望对大家的学习有帮助,程序不是很完善,请大家见谅!
  • Android 监控目录文件变化

    千次阅读 2021-12-10 11:38:54
    公司要求做一个监控系统某一个目录下文件变化,新增或者删除文件变化的功能,查阅了一些资料,现在做一个总结 android.os包下的FileObserver类是Android提供的一个用于监听文件访问、创建、修改、删除、移动等操作...
  • 使用java实现对文件监控功能,当文件发生修改,实时获取更新内容。 1.要求对目标文件实时监控 2.按行读取文件更行内容 3.将获取内容进行落库 二、使用技术: 2.1 commons-io 使用Commons-io的monitor下的...
  • 监控Linux文件变化的各种方法

    千次阅读 2021-10-12 14:27:49
    本文虫虫就给大家来说说系统文件变化的监控。 概述 在*nix体系一切皆文件,系统文件的变化往往反应着系统的变化,比如系统应用的更新、系统的操作活动(可以用安全审计来确定)或系统被黑。根据虫虫多年来...
  • 文件监控小工具

    2011-11-12 19:09:06
    文件监控,查看更改的文件,发现更改的信息后显示出来
  • windows下的文件服务器监控

    千次阅读 2019-11-11 14:52:35
    windows下的文件服务器监控 1、使用Windows自带的管理工具进行查看当前服务器连接的用户及打开的文件,但是该功能比较简单,无法对文件进行监控,比如什么时间哪个用户连接到共享文件夹对该文件夹的文件进行过什么...
  • 使用WatchService类做文件监控总结

    千次阅读 2017-11-27 17:48:38
    由于项目中要求做一个数据交互功能,大概就是为外系统将一些数据导入到本系统,数据中涉及到大量图片,以及文档,或其他资料,大小大概...1、项目初始化后,开启一个线程做文件监控服务(此处建议是重新开启一个线程,
  • 今天看到一网友写的 Java 文件监控,实时监控文件加载 ,突然想到Commons-io中已有此功能的实现,先温习下 写个简单的Demo:   Java代码   package wy.util.filemonitor; import java.io.File; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 747,100
精华内容 298,840
关键字:

文件监控