Machine learning anomaly detection of process-loaded DLLs

1. A method comprising:

monitoring, by an endpoint device, loading of dynamically loaded libraries (DLLs) by a process

generating, by the endpoint device, a representation of the DLLs;

transmitting, by the endpoint device, the process and the representation to a management device to detect in a machine learning manner whether loading of the DLLs during execution of the process was anomalous;

receiving, by the endpoint device, an indication from the management device that the loading of the DLLs was anomalous; and

responsively preventing, by the endpoint device, the process from executing again on the endpoint device.

2. The method of claim 1 , wherein the representation of the DLLs is an endpoint-independent representation of the DLLs, the method further comprising:

generating, by the endpoint device, a hash of the endpoint-independent representation,

wherein transmitting the process and the representation comprises transmitting the process and the hash.

3. The method of claim 2 , wherein transmitting the process and the hash to the management device comprises:

transmitting an identifier of the process and the hash to the management device.

4. The method of claim 1 , wherein loading of the DLLs is monitored during execution of the process,

and wherein the representation of the DLLs is generated upon exiting of the process.

5. The method of claim 1 , wherein generating the representation comprises:

concatenating identifiers of the DLLs,

wherein the concatenated identifiers of the DLLs constitute the representation.

6. The method of claim 5 , further comprising:

prior to generating the representation, ordering the identifiers of the DLLs.

7. The method of claim 5 , wherein the identifiers of the DLLs comprise file paths of the DLLs, and wherein the method further comprises:

prior to generating the representation, removing device-specific and volume-specific information from the file paths of the DLLs.

8. A non-transitory computer-readable data storage medium storing program code executable by an endpoint device, the program code comprising:

kernel-side code to:

during execution of a process on the endpoint device, monitor loading of dynamically loaded libraries (DLLs) by the process; and

transmit an identifier of the process and identifiers of the DLLs;

user-side code to:

receive the identifier of the process and the identifiers of the DLLs from the kernel-side code;

generate an endpoint-independent representation of the identifiers of the DLLs upon exiting of the process;

generate a hash of the endpoint-independent representation; and

transmit the identifier of the process and the hash to a management device to detect in a machine learning manner whether loading of the DLLs during execution of the process was anomalous.

9. The non-transitory computer-readable data storage medium of claim 8 , wherein security code of the program code is to prevent the process from executing again on the computing device responsive to receiving an indication from the management device that the loading of the DLLs during the execution of the process was anomalous.

10. The non-transitory computer-readable data storage medium of claim 8 , wherein the kernel-side code is further to transmit a process-start message including the identifier of the process upon starting of the process,

and wherein the user-side code is further to receive the process-start message from the kernel-side code and responsively add an entry for the identifier of the process to a data structure.

11. The non-transitory computer-readable data storage medium of claim 10 , wherein the kernel-side code is to transmit the identifier of the process and the identifiers of the DLLs by:

each of a plurality of times the process loads one of the DLLs, transmit to the user-side code a DLL-load message including the identifier of the process and the identifier of the one of the DLLs, the user-side code receiving the DLL-load message,

and wherein the user-side code is further to, responsive to receiving the DLL-load message, add the identifier of the one of the DLLs to the entry for the identifier of the process.

12. The non-transitory computer-readable data storage medium of claim 11 , wherein the user-side code is to, when adding the identifier of the one of the DLLs to the entry for the identifier of the process, order the identifier of the one of the DLLs relative to identifiers for other DLLs previously added to the entry for the identifier of the process.

13. The non-transitory computer-readable data storage medium of claim 11 , wherein the identifier of the one of the DLLs comprises a file path of the one of the DLLs, and

wherein the user-side code is to, when adding the identifier of the one of the DLLs to the entry for the identifier of the process, remove device-specific and volume-specific information from the file path.

14. The non-transitory computer-readable data storage medium of claim 11 , wherein the kernel-side code is further to transmit a process-stop message including the identifier of the process upon exiting of the process,

and wherein the user-side code is further to receive the process-stop message from the kernel-side code and responsively generate the endpoint-independent representation.

15. The non-transitory computer-readable data storage medium of claim 14 , wherein the user-side code is further to, when generating the endpoint-independent representation, order the identifiers of the DLLs added to the entry for the identifier of the process.

16. The non-transitory computer-readable data storage medium of claim 14 , wherein the identifiers of the DLLs comprises file paths of the DLLs,

and wherein the user-side code is further to, when generating the endpoint-independent representation, remove device-specific and volume-specific information from the file paths of the DLLs.

17. The non-transitory computer-readable data storage medium of claim 14 , wherein the user-side code is to generate the endpoint-independent representation by:

concatenating the identifiers of the DLLs added to the entry for the identifier of the process,

wherein the concatenated identifiers of the DLLs constitute the endpoint-independent representation.

18. A management device comprising:

a processor; and

a memory storing program code executable by the processor to:

receive identifiers of processes and representations from endpoint devices, each representation of dynamically loaded libraries (DLLs) loaded during execution of a corresponding process on a corresponding endpoint device;

train a machine learning model from the identifiers of the processes and the representations that have been received, the machine learning model used to detect anomalous DLL loading during process execution on the endpoint devices;

each of a plurality of times that the identifier of one of the processes and one of the representations is received from one of the endpoint devices, detect whether loading of the DLLs of the one of the representations during the execution of the one of the processes was anomalous, using the machine learning model; and

in response to detecting that the loading of the DLLs of the one of the representations during the execution of the one of the processes was anomalous, preventing the one of the processes from executing again on the one of the endpoint devices.

19. The management device of claim 18 , wherein each representation comprises an endpoint device-independent representation.

20. The management device of claim 18 , wherein each representation comprises a hash of an endpoint device-independent representation.