• The YAML packages currently available for weatheralerts v0.1.2 are not compatible with prior versions of weatheralerts. Older YAML packages should still work with weatheralerts v0.1.2, however, the most recent YAML package files contain new features and fixes.

This qickstart install guide assumes you are already familiar with custom component installation and with the Home Assistant YAML configuration. If you need more detailed step-by-step instructions, check the links at the bottom for detailed instructions. Troubleshooting information, weatheralerts YAML package information, and Lovelace UI examples are also included in the Links at the bottom.

Install the weatheralerts integration via HACS. After installing via HACS, don’t restart Home Assistant yet. We will do that after completing the YAML platform configuration.

You will need to find your zone and county codes by looking for your state or marine zone at https://alerts.weather.gov/. Once at https://alerts.weather.gov/, click the Land area with zones link and you will find a list of states with Public Zones and County Zones links. Once you find your state , click into the Public Zones and County Zones links and find the respective codes for your county. All you will need are just the first two letters (your state abbreviation) and the last three digits (zone/county ID number) of your zone code and county code to put into the platform configuration. The zone and county ID numbers are not usually the same number, so be sure to look up both codes. For marine zones, go to https://alerts.weather.gov/, click the Marine regions/areas with zones link and you will find a list of marine areas with Zones links. In the Zones link for the marine area you are interested in, find the exact marine zone. The first two letters of the marine zone is what will be used for the state configuration option, and the last three digits is what will be used for the zone configuration option (omit any leading zeros).

Once installed and you have your state (or marine zone) abbreviation and ID numbers, add the weatheralerts sensor platform to your configuration. If your state is Wisconsin and your county is Outagamie, then the state abbreviation is WI, the zone ID number is 038, and the county ID number is 087. For the ID numbers, remove any leading zeros and your YAML platform configuration would look something like this:

sensor:
  platform: weatheralerts
  state: WI
  zone: 38
  county: 87

Once your configuration is saved, restart Home Assistant.

That completes the integration (custom component) installation.

Check the Links below for more detailed instructions, troubleshooting, and for YAML package and Lovelace UI usage and examples.

Check the Breaking Changes section of this README to see if you need to manually update the YAML packages or make any changes to your custom YAML or Lovelace UI cards. Simply use the Update button for the weatheralerts integration within HACS if there are no breaking changes and then restart Home Assistant.

• Detailed Instructions
• Troubleshooting
• YAML Package Info
• Lovelace UI Examples
• GitHub Repository
• View Issues/Feature Requests
• Report an Issue/Feature Request
• Changelog

You can reconfigure the integration through the Home Assistant UI:

1. Go to Settings > Devices & Services.
2. Find the Weather Alerts integration and click on it.
3. Click Configure.
4. Update the State, Zone, and County values.
5. Click Save. The integration will automatically reload.

• Add more documentation
• Add config flow to allow UI-based configuration (eliminate yaml-based platform configuration)
• Create alternative (possibly simpler) YAML package or move some template sensors into the integration
• Add backup weather alert source for occasions when weather.gov json feed is experiencing an outage
• Add Canadian weather alerts

Darling Donuts is a delightful microservices-based website designed to showcase and sell a variety of delicious donuts. The project is built on the MERN (MongoDB, Express, React, Node.js) stack, ensuring a seamless user experience and efficient management of the donut catalog. With an attractive user interface and a wide selection of mouthwatering donuts, Darling Donuts is the perfect place for donut enthusiasts to satisfy their cravings.

• Microservices Architecture: The website is designed using a microservices architecture, allowing for modularity, scalability, and easy maintenance of individual components.
• MongoDB: The application leverages MongoDB to store and manage the donut catalog, ensuring a flexible and efficient data storage solution.
• Express: The Express.js framework is used to develop the server-side of the application, handling HTTP requests and business logic.
• React: The website’s frontend is built using React, providing a dynamic and interactive user interface for an enhanced shopping experience.
• Node.js: The application’s backend is developed using Node.js, enabling fast and event-driven processing of data and requests.
• User Authentication: Darling Donuts incorporates user authentication to provide personalized experiences, order tracking, and secure payment processing.
• Cart Functionality: Customers can easily add their favorite donuts to their shopping cart, allowing for seamless order management.
• Order Tracking: The website offers real-time order tracking, enabling customers to monitor the status of their orders and estimated delivery times.
• Payment Integration: Secure payment gateways are integrated, ensuring safe and hassle-free transactions.
• Responsive Design: Darling Donuts is optimized for all devices, providing a consistent user experience across desktops, tablets, and smartphones.
• Admin Dashboard: An intuitive admin dashboard is included to manage the donut catalog, process orders, and track customer data efficiently.

• MongoDB: A popular NoSQL database used for efficient and scalable data storage.
• Express: A minimalist web application framework for Node.js, facilitating server-side development.
• React: A powerful JavaScript library for building dynamic user interfaces.
• Node.js: A runtime environment for executing JavaScript code on the server-side.
• Authentication: Libraries or techniques are used for user authentication and session management.
• Payment Integration: Secure and reliable payment gateway integration to facilitate online transactions.
• Microservices Architecture: Utilized to ensure modularity, scalability, and easy maintenance of components.

To run the Darling Donuts website locally, follow these steps:

1. Clone the repository to your local machine.
2. Navigate to the project directory and install the required dependencies using npm or yarn.
3. Set up the MongoDB database and configure the necessary environment variables.
4. Start the development server using the appropriate npm/yarn command.
5. Open your preferred web browser and access the Darling Donuts website at http://localhost:3000 (or a different port if specified).

Contributions from the open-source community are welcome to enhance the Darling Donuts website further. If you wish to contribute, please follow the standard pull request process after making the necessary changes.

This project is licensed under the MIT License, allowing you to freely use, modify, and distribute the code.

We express our appreciation to the MERN stack creators, MongoDB, Express.js, React, and Node.js, for providing robust technologies that contributed to the development of Darling Donuts.

For any inquiries or feedback, please feel free to contact us at mahmoudh.buss@gmail.com or via GitHub.

Satisfy your sweet tooth with Darling Donuts! 🍩❤️

A modular, unopinonated event-based web framework – written in TypeScript for Node.js

This package is currently undergoing development! Follow us on Twitter for updates and release announcements!

• Write solid code: Promise-based, strongly typed API in TypeScript
• Reuse your code: Modular and flexible event-based structure
  • Stack your Layers
  • Process an event as it trickles down through each Layer sequentially
  • Use Services to connect your application with the outside world (DBs, other APIs, etc.)
• Scale your app: distributed event processing (coming soon)
• Do it your way: Yagura gives you an unopinionated structure – you choose how to implement your solution

Do you use Yagura? Tell us more, we’d love to learn how to make it better: Twitter

Yagura (櫓, 矢倉) is the Japanese word for “tower” or “scaffold”

As software development keeps becoming more iterative, it’s becoming harder and harder to foresee how much complexity the project will increase, which in turn leads to either under- or over-engineering.

Solution: build your application as a modular event-handling pipeline, where, as events trickle down, each Layer can provide:

• Data processing
• Routing
• Middleware
• Additional functionality
• Backwards compatibility for bottom layers

…and more! By laying out your code in a clear, sequential event processing scaffold, you can freely* and easily add/remove entire parts of an application while maintaining integrity

(_{^{*as long as you’ve decoupled it properly; we’re not responsible for developers writing an entire real-time “BigData” processing service with an HTTP API as a single Layer. Always follow good programming practices!}})

import { Yagura } from '@yagura/yagura'
import ... from '...' // roll out your own layers and services!

const app: Yagura = await Yagura.start(
  // Layers
  // quickly remove, reorder and replace each of the lines to reconfigure your pipeline with ease!
  [
      new MiddlewareLayer(),              // Generic HTTP middleware (ie. parse headers, request logging, handing multi-part...)
      new AuthenticationLayer({           // Authentication middleware (ie. verify whether user is authenticated, provide login routes...)
          requireLogin: true
      }),
      new ValidationLayer(),              // Request validation middleware (ie. verify request format, check required parameters...)
      new ResourceLayer(),                // HTTP resource layer (ie. perform queries, fetch data, elaborate response...)
      new ParsingLayer(),                 // Response parsing (ie. ensure object serialization, strip secret data, encode text according to locale...)
  ],
  // Services
  [
      new CoolLogger({                // Custom logger
          minLevel: 'debug'
      }),
      new CrashNotifier({             // Crash notification utility
          email: 'admin@example.com'
      }),
      new DatabaseConnection({        // Database access
          host: 'db.secretserver.com',
          username: 'root',
          password: 'S0meTh1ngStr0nG!',
          db: 'cool-data'
      }),
      new WebServer({                 // Simple HTTP web server
          port: 3000,
          https: true
      })
  ]
);

If you discover a security vulnerability in Yagura, please see Security Policies and Procedures.

The quickest way to get started with Yagura is to create a new Node.js project with Yagura as a dependency:

$ npm install @yagura/yagura

Check out Yagura’s extension packages to develop specific types of applications:

• @yagura/http HTTP server and API development tools (supports HTTP/2!)
• @yagura/realtime base Layers for realtime-based server development (such as MQTT, WebSockets, raw sockets (TCP/UDP), etc.)

TBD

To run the test suite, first install the dependencies, then run npm run test:

$ npm install --devDependencies
$ npm run test

The original author of Yagura is James Kerber

List of all contributors

GNU GPLv3

A modular, unopinonated event-based web framework – written in TypeScript for Node.js

This package is currently undergoing development! Follow us on Twitter for updates and release announcements!

• Write solid code: Promise-based, strongly typed API in TypeScript
• Reuse your code: Modular and flexible event-based structure
  • Stack your Layers
  • Process an event as it trickles down through each Layer sequentially
  • Use Services to connect your application with the outside world (DBs, other APIs, etc.)
• Scale your app: distributed event processing (coming soon)
• Do it your way: Yagura gives you an unopinionated structure – you choose how to implement your solution

Do you use Yagura? Tell us more, we’d love to learn how to make it better: Twitter

Yagura (櫓, 矢倉) is the Japanese word for “tower” or “scaffold”

As software development keeps becoming more iterative, it’s becoming harder and harder to foresee how much complexity the project will increase, which in turn leads to either under- or over-engineering.

Solution: build your application as a modular event-handling pipeline, where, as events trickle down, each Layer can provide:

• Data processing
• Routing
• Middleware
• Additional functionality
• Backwards compatibility for bottom layers

…and more! By laying out your code in a clear, sequential event processing scaffold, you can freely* and easily add/remove entire parts of an application while maintaining integrity

(_{^{*as long as you’ve decoupled it properly; we’re not responsible for developers writing an entire real-time “BigData” processing service with an HTTP API as a single Layer. Always follow good programming practices!}})

import { Yagura } from '@yagura/yagura'
import ... from '...' // roll out your own layers and services!

const app: Yagura = await Yagura.start(
  // Layers
  // quickly remove, reorder and replace each of the lines to reconfigure your pipeline with ease!
  [
      new MiddlewareLayer(),              // Generic HTTP middleware (ie. parse headers, request logging, handing multi-part...)
      new AuthenticationLayer({           // Authentication middleware (ie. verify whether user is authenticated, provide login routes...)
          requireLogin: true
      }),
      new ValidationLayer(),              // Request validation middleware (ie. verify request format, check required parameters...)
      new ResourceLayer(),                // HTTP resource layer (ie. perform queries, fetch data, elaborate response...)
      new ParsingLayer(),                 // Response parsing (ie. ensure object serialization, strip secret data, encode text according to locale...)
  ],
  // Services
  [
      new CoolLogger({                // Custom logger
          minLevel: 'debug'
      }),
      new CrashNotifier({             // Crash notification utility
          email: 'admin@example.com'
      }),
      new DatabaseConnection({        // Database access
          host: 'db.secretserver.com',
          username: 'root',
          password: 'S0meTh1ngStr0nG!',
          db: 'cool-data'
      }),
      new WebServer({                 // Simple HTTP web server
          port: 3000,
          https: true
      })
  ]
);

If you discover a security vulnerability in Yagura, please see Security Policies and Procedures.

The quickest way to get started with Yagura is to create a new Node.js project with Yagura as a dependency:

$ npm install @yagura/yagura

Check out Yagura’s extension packages to develop specific types of applications:

• @yagura/http HTTP server and API development tools (supports HTTP/2!)
• @yagura/realtime base Layers for realtime-based server development (such as MQTT, WebSockets, raw sockets (TCP/UDP), etc.)

TBD

To run the test suite, first install the dependencies, then run npm run test:

$ npm install --devDependencies
$ npm run test

The original author of Yagura is James Kerber

List of all contributors

GNU GPLv3

Green Day creates workspaces and tests for Atcoder contests
（日本語で解説した記事はこちら)

Add this line to your application’s Gemfile:

gem 'green_day'

And then execute:

$ bundle

Or install it yourself as:

$ gem install green_day

login(this command stores your cookie as .cookie-store in current directory)

$ bundle exec green_day login

If you want to delete session, remove .cookie-store

This command creates directory and spec.

$ bundle exec green_day new <contest-name>

For example

$ bundle exec green_day new abc150

 abc150
 ├── A.rb
 ├── B.rb
 ├── C.rb
 ├── D.rb
 ├── E.rb
 ├── F.rb
 └── spec
     ├── A_spec.rb
     ├── B_spec.rb
     ├── C_spec.rb
     ├── D_spec.rb
     ├── E_spec.rb
     └── F_spec.rb

RSpec.describe 'abc150/A.rb' do
  it 'test with "2 900\n"' do
    io = IO.popen('ruby abc150/A.rb', 'w+')
    io.puts("2 900\n")
    io.close_write
    expect(io.readlines.join).to eq("Yes\n")
  end

  it 'test with "1 501\n"' do
    io = IO.popen('ruby abc150/A.rb', 'w+')
    io.puts("1 501\n")
    io.close_write
    expect(io.readlines.join).to eq("No\n")
  end

  it 'test with "4 2000\n"' do
    io = IO.popen('ruby abc150/A.rb', 'w+')
    io.puts("4 2000\n")
    io.close_write
    expect(io.readlines.join).to eq("Yes\n")
  end

end

You can use a template file for creating specs.
GreenDay uses template.rb in the working directory as a template file.

requires "math"
x = gets.to_i

After checking out the repo, run bin/setup to install dependencies. Then, run rake spec to run the tests. You can also run bin/console for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run bundle exec rake install. To release a new version, update the version number in version.rb, and then run bundle exec rake release, which will create a git tag for the version, push git commits and tags, and push the .gem file to rubygems.org.

Bug reports and pull requests are welcome on GitHub at https://github.com/QWYNG/green_day. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the Contributor Covenant code of conduct.

The gem is available as open source under the terms of the MIT License.

Everyone interacting in the GreenDay project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the code of conduct.

A collection of awesome software, libraries, documents, books, resources and cool stuff about malware analysis in cybersecurity. Thanks to all contributors, you’re awesome and wouldn’t be possible without you! Our goal is to build a categorized community-driven collection of very well-known resources.

Malware analysis is the study or process of determining the functionality, origin and potential impact of a given malware sample such as a virus, worm, trojan horse, rootkit, or backdoor.

• Malware detection — To better protect your organization, you need to be able to identify compromising threats and vulnerabilities.
• Threat response — To help you understand how these threats work so you can react accordingly to them.
• Malware research — This can help you to better understand how specific types of malware work, where they originated, and what differentiates them.

• Malware Collection
  • Anonymizers
  • Honeypots
  • Malware Corpora
• Open Source Threat Intelligence
  • Tools
  • Other Resources
• Detection and Classification
• Online Scanners and Sandboxes
• Domain Analysis
• Browser Malware
• Documents and Shellcode
• File Carving
• Deobfuscation
• Debugging and Reverse Engineering
• Network
• Memory Forensics
• Windows Artifacts
• Storage and Workflow
• Miscellaneous
• Resources
  • Books
  • Other
• Related Awesome Lists
• Contributing
• Thanks

View Chinese translation: 恶意软件分析大合集.md.

Web traffic anonymizers for analysts.

• Anonymouse.org – A free, web based anonymizer.
• OpenVPN – VPN software and hosting solutions.
• Privoxy – An open source proxy server with some privacy features.
• Tor – The Onion Router, for browsing the web without leaving traces of the client IP.

Trap and collect your own samples.

• Conpot – ICS/SCADA honeypot.
• Cowrie – SSH honeypot, based on Kippo.
• DemoHunter – Low interaction Distributed Honeypots.
• Dionaea – Honeypot designed to trap malware.
• Glastopf – Web application honeypot.
• Honeyd – Create a virtual honeynet.
• HoneyDrive – Honeypot bundle Linux distro.
• Honeytrap – Opensource system for running, monitoring and managing honeypots.
• MHN – MHN is a centralized server for management and data collection of honeypots. MHN allows you to deploy sensors quickly and to collect data immediately, viewable from a neat web interface.
• Mnemosyne – A normalizer for honeypot data; supports Dionaea.
• Thug – Low interaction honeyclient, for investigating malicious websites.

Malware samples collected for analysis.

• Clean MX – Realtime database of malware and malicious domains.
• Contagio – A collection of recent malware samples and analyses.
• Exploit Database – Exploit and shellcode samples.
• Infosec – CERT-PA – Malware samples collection and analysis.
• InQuest Labs – Evergrowing searchable corpus of malicious Microsoft documents.
• Javascript Mallware Collection – Collection of almost 40.000 javascript malware samples
• Malpedia – A resource providing rapid identification and actionable context for malware investigations.
• Malshare – Large repository of malware actively scrapped from malicious sites.
• Open Malware Project – Sample information and downloads. Formerly Offensive Computing.
• Ragpicker – Plugin based malware crawler with pre-analysis and reporting functionalities
• theZoo – Live malware samples for analysts.
• Tracker h3x – Agregator for malware corpus tracker and malicious download sites.
• vduddu malware repo – Collection of various malware files and source code.
• VirusBay – Community-Based malware repository and social network.
• ViruSign – Malware database that detected by many anti malware programs except ClamAV.
• VirusShare – Malware repository, registration required.
• VX Vault – Active collection of malware samples.
• Zeltser’s Sources – A list of malware sample sources put together by Lenny Zeltser.
• Zeus Source Code – Source for the Zeus trojan leaked in 2011.
• VX Underground – Massive and growing collection of free malware samples.

Harvest and analyze IOCs.

• AbuseHelper – An open-source framework for receiving and redistributing abuse feeds and threat intel.
• AlienVault Open Threat Exchange – Share and collaborate in developing Threat Intelligence.
• Combine – Tool to gather Threat Intelligence indicators from publicly available sources.
• Fileintel – Pull intelligence per file hash.
• Hostintel – Pull intelligence per host.
• IntelMQ – A tool for CERTs for processing incident data using a message queue.
• IOC Editor – A free editor for XML IOC files.
• iocextract – Advanced Indicator of Compromise (IOC) extractor, Python library and command-line tool.
• ioc_writer – Python library for working with OpenIOC objects, from Mandiant.
• MalPipe – Malware/IOC ingestion and processing engine, that enriches collected data.
• Massive Octo Spice – Previously known as CIF (Collective Intelligence Framework). Aggregates IOCs from various lists. Curated by the CSIRT Gadgets Foundation.
• MISP – Malware Information Sharing Platform curated by The MISP Project.
• Pulsedive – Free, community-driven threat intelligence platform collecting IOCs from open-source feeds.
• PyIOCe – A Python OpenIOC editor.
• RiskIQ – Research, connect, tag and share IPs and domains. (Was PassiveTotal.)
• threataggregator – Aggregates security threats from a number of sources, including some of those listed below in other resources.
• ThreatConnect – TC Open allows you to see and share open source threat data, with support and validation from our free community.
• ThreatCrowd – A search engine for threats, with graphical visualization.
• ThreatIngestor – Build automated threat intel pipelines sourcing from Twitter, RSS, GitHub, and more.
• ThreatTracker – A Python script to monitor and generate alerts based on IOCs indexed by a set of Google Custom Search Engines.
• TIQ-test – Data visualization and statistical analysis of Threat Intelligence feeds.

Threat intelligence and IOC resources.

• Autoshun (list) – Snort plugin and blocklist.
• Bambenek Consulting Feeds – OSINT feeds based on malicious DGA algorithms.
• Fidelis Barncat – Extensive malware config database (must request access).
• CI Army (list) – Network security blocklists.
• Critical Stack- Free Intel Market – Free intel aggregator with deduplication featuring 90+ feeds and over 1.2M indicators.
• Cybercrime tracker – Multiple botnet active tracker.
• FireEye IOCs – Indicators of Compromise shared publicly by FireEye.
• FireHOL IP Lists – Analytics for 350+ IP lists with a focus on attacks, malware and abuse. Evolution, Changes History, Country Maps, Age of IPs listed, Retention Policy, Overlaps.
• HoneyDB – Community driven honeypot sensor data collection and aggregation.
• hpfeeds – Honeypot feed protocol.
• Infosec – CERT-PA lists (IPs – Domains – URLs) – Blocklist service.
• InQuest REPdb – Continuous aggregation of IOCs from a variety of open reputation sources.
• InQuest IOCdb – Continuous aggregation of IOCs from a variety of blogs, Github repos, and Twitter.
• Internet Storm Center (DShield) – Diary and searchable incident database, with a web API. (unofficial Python library).
• malc0de – Searchable incident database.
• Malware Domain List – Search and share malicious URLs.
• MetaDefender Threat Intelligence Feed – List of the most looked up file hashes from MetaDefender Cloud.
• OpenIOC – Framework for sharing threat intelligence.
• Proofpoint Threat Intelligence – Rulesets and more. (Formerly Emerging Threats.)
• Ransomware overview – A list of ransomware overview with details, detection and prevention.
• STIX – Structured Threat Information eXpression – Standardized language to represent and share cyber threat information. Related efforts from MITRE:
  • CAPEC – Common Attack Pattern Enumeration and Classification
  • CybOX – Cyber Observables eXpression
  • MAEC – Malware Attribute Enumeration and Characterization
  • TAXII – Trusted Automated eXchange of Indicator Information
• SystemLookup – SystemLookup hosts a collection of lists that provide information on the components of legitimate and potentially unwanted programs.
• ThreatMiner – Data mining portal for threat intelligence, with search.
• threatRECON – Search for indicators, up to 1000 free per month.
• ThreatShare – C2 panel tracker
• Yara rules – Yara rules repository.
• YETI – Yeti is a platform meant to organize observables, indicators of compromise, TTPs, and knowledge on threats in a single, unified repository.
• ZeuS Tracker – ZeuS blocklists.

Antivirus and other malware identification tools

• AnalyzePE – Wrapper for a variety of tools for reporting on Windows PE files.
• Assemblyline – A scalable distributed file analysis framework.
• BinaryAlert – An open source, serverless AWS pipeline that scans and alerts on uploaded files based on a set of YARA rules.
• capa – Detects capabilities in executable files.
• chkrootkit – Local Linux rootkit detection.
• ClamAV – Open source antivirus engine.
• Detect It Easy(DiE) – A program for determining types of files.
• Exeinfo PE – Packer, compressor detector, unpack info, internal exe tools.
• ExifTool – Read, write and edit file metadata.
• File Scanning Framework – Modular, recursive file scanning solution.
• fn2yara – FN2Yara is a tool to generate Yara signatures for matching functions (code) in an executable program.
• Generic File Parser – A Single Library Parser to extract meta information,static analysis and detect macros within the files.
• hashdeep – Compute digest hashes with a variety of algorithms.
• HashCheck – Windows shell extension to compute hashes with a variety of algorithms.
• Loki – Host based scanner for IOCs.
• Malfunction – Catalog and compare malware at a function level.
• Manalyze – Static analyzer for PE executables.
• MASTIFF – Static analysis framework.
• MultiScanner – Modular file scanning/analysis framework
• Nauz File Detector(NFD) – Linker/Compiler/Tool detector for Windows, Linux and MacOS.
• nsrllookup – A tool for looking up hashes in NIST’s National Software Reference Library database.
• packerid – A cross-platform Python alternative to PEiD.
• PE-bear – Reversing tool for PE files.
• PEframe – PEframe is an open source tool to perform static analysis on Portable Executable malware and malicious MS Office documents.
• PEV – A multiplatform toolkit to work with PE files, providing feature-rich tools for proper analysis of suspicious binaries.
• PortEx – Java library to analyse PE files with a special focus on malware analysis and PE malformation robustness.
• Quark-Engine – An Obfuscation-Neglect Android Malware Scoring System
• Rootkit Hunter – Detect Linux rootkits.
• ssdeep – Compute fuzzy hashes.
• totalhash.py – Python script for easy searching of the TotalHash.cymru.com database.
• TrID – File identifier.
• YARA – Pattern matching tool for analysts.
• Yara rules generator – Generate yara rules based on a set of malware samples. Also contains a good strings DB to avoid false positives.
• Yara Finder – A simple tool to yara match the file against various yara rules to find the indicators of suspicion.

Web-based multi-AV scanners, and malware sandboxes for automated analysis.

• anlyz.io – Online sandbox.
• any.run – Online interactive sandbox.
• AndroTotal – Free online analysis of APKs against multiple mobile antivirus apps.
• AVCaesar – Malware.lu online scanner and malware repository.
• BoomBox – Automatic deployment of Cuckoo Sandbox malware lab using Packer and Vagrant.
• Cryptam – Analyze suspicious office documents.
• Cuckoo Sandbox – Open source, self hosted sandbox and automated analysis system.
• cuckoo-modified – Modified version of Cuckoo Sandbox released under the GPL. Not merged upstream due to legal concerns by the author.
• cuckoo-modified-api – A Python API used to control a cuckoo-modified sandbox.
• DeepViz – Multi-format file analyzer with machine-learning classification.
• detux – A sandbox developed to do traffic analysis of Linux malwares and capturing IOCs.
• DRAKVUF – Dynamic malware analysis system.
• firmware.re – Unpacks, scans and analyzes almost any firmware package.
• HaboMalHunter – An Automated Malware Analysis Tool for Linux ELF Files.
• Hybrid Analysis – Online malware analysis tool, powered by VxSandbox.
• Intezer – Detect, analyze, and categorize malware by identifying code reuse and code similarities.
• IRMA – An asynchronous and customizable analysis platform for suspicious files.
• Joe Sandbox – Deep malware analysis with Joe Sandbox.
• Jotti – Free online multi-AV scanner.
• Limon – Sandbox for Analyzing Linux Malware.
• Malheur – Automatic sandboxed analysis of malware behavior.
• malice.io – Massively scalable malware analysis framework.
• malsub – A Python RESTful API framework for online malware and URL analysis services.
• Malware config – Extract, decode and display online the configuration settings from common malwares.
• MalwareAnalyser.io – Online malware anomaly-based static analyser with heuristic detection engine powered by data mining and machine learning.
• Malwr – Free analysis with an online Cuckoo Sandbox instance.
• MetaDefender Cloud – Scan a file, hash, IP, URL or domain address for malware for free.
• NetworkTotal – A service that analyzes pcap files and facilitates the quick detection of viruses, worms, trojans, and all kinds of malware using Suricata configured with EmergingThreats Pro.
• Noriben – Uses Sysinternals Procmon to collect information about malware in a sandboxed environment.
• PacketTotal – PacketTotal is an online engine for analyzing .pcap files, and visualizing the network traffic within.
• PDF Examiner – Analyse suspicious PDF files.
• ProcDot – A graphical malware analysis tool kit.
• Recomposer – A helper script for safely uploading binaries to sandbox sites.
• sandboxapi – Python library for building integrations with several open source and commercial malware sandboxes.
• SEE – Sandboxed Execution Environment (SEE) is a framework for building test automation in secured Environments.
• SEKOIA Dropper Analysis – Online dropper analysis (Js, VBScript, Microsoft Office, PDF).
• VirusTotal – Free online analysis of malware samples and URLs
• Visualize_Logs – Open source visualization library and command line tools for logs. (Cuckoo, Procmon, more to come…)
• Zeltser’s List – Free automated sandboxes and services, compiled by Lenny Zeltser.

Inspect domains and IP addresses.

• AbuseIPDB – AbuseIPDB is a project dedicated to helping combat the spread of hackers, spammers, and abusive activity on the internet.
• badips.com – Community based IP blacklist service.
• boomerang – A tool designed for consistent and safe capture of off network web resources.
• Cymon – Threat intelligence tracker, with IP/domain/hash search.
• Desenmascara.me – One click tool to retrieve as much metadata as possible for a website and to assess its good standing.
• Dig – Free online dig and other network tools.
• dnstwist – Domain name permutation engine for detecting typo squatting, phishing and corporate espionage.
• IPinfo – Gather information about an IP or domain by searching online resources.
• Machinae – OSINT tool for gathering information about URLs, IPs, or hashes. Similar to Automator.
• mailchecker – Cross-language temporary email detection library.
• MaltegoVT – Maltego transform for the VirusTotal API. Allows domain/IP research, and searching for file hashes and scan reports.
• Multi rbl – Multiple DNS blacklist and forward confirmed reverse DNS lookup over more than 300 RBLs.
• NormShield Services – Free API Services for detecting possible phishing domains, blacklisted ip addresses and breached accounts.
• PhishStats – Phishing Statistics with search for IP, domain and website title
• Spyse – subdomains, whois, realted domains, DNS, hosts AS, SSL/TLS info,
• SecurityTrails – Historical and current WHOIS, historical and current DNS records, similar domains, certificate information and other domain and IP related API and tools.
• SpamCop – IP based spam block list.
• SpamHaus – Block list based on domains and IPs.
• Sucuri SiteCheck – Free Website Malware and Security Scanner.
• Talos Intelligence – Search for IP, domain or network owner. (Previously SenderBase.)
• TekDefense Automater – OSINT tool for gathering information about URLs, IPs, or hashes.
• URLhaus – A project from abuse.ch with the goal of sharing malicious URLs that are being used for malware distribution.
• URLQuery – Free URL Scanner.
• urlscan.io – Free URL Scanner & domain information.
• Whois – DomainTools free online whois search.
• Zeltser’s List – Free online tools for researching malicious websites, compiled by Lenny Zeltser.
• ZScalar Zulu – Zulu URL Risk Analyzer.

Analyze malicious URLs. See also the domain analysis and documents and shellcode sections.

• Bytecode Viewer – Combines multiple Java bytecode viewers and decompilers into one tool, including APK/DEX support.
• Firebug – Firefox extension for web development.
• Java Decompiler – Decompile and inspect Java apps.
• Java IDX Parser – Parses Java IDX cache files.
• JSDetox – JavaScript malware analysis tool.
• jsunpack-n – A javascript unpacker that emulates browser functionality.
• Krakatau – Java decompiler, assembler, and disassembler.
• Malzilla – Analyze malicious web pages.
• RABCDAsm – A “Robust ActionScript Bytecode Disassembler.”
• SWF Investigator – Static and dynamic analysis of SWF applications.
• swftools – Tools for working with Adobe Flash files.
• xxxswf – A Python script for analyzing Flash files.

Analyze malicious JS and shellcode from PDFs and Office documents. See also the browser malware section.

• AnalyzePDF – A tool for analyzing PDFs and attempting to determine whether they are malicious.
• box-js – A tool for studying JavaScript malware, featuring JScript/WScript support and ActiveX emulation.
• diStorm – Disassembler for analyzing malicious shellcode.
• InQuest Deep File Inspection – Upload common malware lures for Deep File Inspection and heuristical analysis.
• JS Beautifier – JavaScript unpacking and deobfuscation.
• libemu – Library and tools for x86 shellcode emulation.
• malpdfobj – Deconstruct malicious PDFs into a JSON representation.
• OfficeMalScanner – Scan for malicious traces in MS Office documents.
• olevba – A script for parsing OLE and OpenXML documents and extracting useful information.
• Origami PDF – A tool for analyzing malicious PDFs, and more.
• PDF Tools – pdfid, pdf-parser, and more from Didier Stevens.
• PDF X-Ray Lite – A PDF analysis tool, the backend-free version of PDF X-RAY.
• peepdf – Python tool for exploring possibly malicious PDFs.
• QuickSand – QuickSand is a compact C framework to analyze suspected malware documents to identify exploits in streams of different encodings and to locate and extract embedded executables.
• Spidermonkey – Mozilla’s JavaScript engine, for debugging malicious JS.

For extracting files from inside disk and memory images.

• bulk_extractor – Fast file carving tool.
• EVTXtract – Carve Windows Event Log files from raw binary data.
• Foremost – File carving tool designed by the US Air Force.
• hachoir3 – Hachoir is a Python library to view and edit a binary stream field by field.
• Scalpel – Another data carving tool.
• SFlock – Nested archive extraction/unpacking (used in Cuckoo Sandbox).

Reverse XOR and other code obfuscation methods.

• Balbuzard – A malware analysis tool for reversing obfuscation (XOR, ROL, etc) and more.
• de4dot – .NET deobfuscator and unpacker.
• ex_pe_xor & iheartxor – Two tools from Alexander Hanel for working with single-byte XOR encoded files.
• FLOSS – The FireEye Labs Obfuscated String Solver uses advanced static analysis techniques to automatically deobfuscate strings from malware binaries.
• NoMoreXOR – Guess a 256 byte XOR key using frequency analysis.
• PackerAttacker – A generic hidden code extractor for Windows malware.
• PyInstaller Extractor – A Python script to extract the contents of a PyInstaller generated Windows executable file. The contents of the pyz file (usually pyc files) present inside the executable are also extracted and automatically fixed so that a Python bytecode decompiler will recognize it.
• uncompyle6 – A cross-version Python bytecode decompiler. Translates Python bytecode back into equivalent Python source code.
• un{i}packer – Automatic and platform-independent unpacker for Windows binaries based on emulation.
• unpacker – Automated malware unpacker for Windows malware based on WinAppDbg.
• unxor – Guess XOR keys using known-plaintext attacks.
• VirtualDeobfuscator – Reverse engineering tool for virtualization wrappers.
• XORBruteForcer – A Python script for brute forcing single-byte XOR keys.
• XORSearch & XORStrings – A couple programs from Didier Stevens for finding XORed data.
• xortool – Guess XOR key length, as well as the key itself.

Disassemblers, debuggers, and other static and dynamic analysis tools.

• angr – Platform-agnostic binary analysis framework developed at UCSB’s Seclab.
• bamfdetect – Identifies and extracts information from bots and other malware.
• BAP – Multiplatform and open source (MIT) binary analysis framework developed at CMU’s Cylab.
• BARF – Multiplatform, open source Binary Analysis and Reverse engineering Framework.
• binnavi – Binary analysis IDE for reverse engineering based on graph visualization.
• Binary ninja – A reversing engineering platform that is an alternative to IDA.
• Binwalk – Firmware analysis tool.
• BluePill – Framework for executing and debugging evasive malware and protected executables.
• Capstone – Disassembly framework for binary analysis and reversing, with support for many architectures and bindings in several languages.
• codebro – Web based code browser using  clang to provide basic code analysis.
• Cutter – GUI for Radare2.
• DECAF (Dynamic Executable Code Analysis Framework) – A binary analysis platform based   on QEMU. DroidScope is now an extension to DECAF.
• dnSpy – .NET assembly editor, decompiler and debugger.
• dotPeek – Free .NET Decompiler and Assembly Browser.
• Evan’s Debugger (EDB) – A modular debugger with a Qt GUI.
• Fibratus – Tool for exploration and tracing of the Windows kernel.
• FPort – Reports open TCP/IP and UDP ports in a live system and maps them to the owning application.
• GDB – The GNU debugger.
• GEF – GDB Enhanced Features, for exploiters and reverse engineers.
• Ghidra – A software reverse engineering (SRE) framework created and maintained by the National Security Agency Research Directorate.
• hackers-grep – A utility to search for strings in PE executables including imports, exports, and debug symbols.
• Hopper – The macOS and Linux Disassembler.
• IDA Pro – Windows disassembler and debugger, with a free evaluation version.
• IDR – Interactive Delphi Reconstructor is a decompiler of Delphi executable files and dynamic libraries.
• Immunity Debugger – Debugger for malware analysis and more, with a Python API.
• ILSpy – ILSpy is the open-source .NET assembly browser and decompiler.
• Kaitai Struct – DSL for file formats / network protocols / data structures reverse engineering and dissection, with code generation for C++, C#, Java, JavaScript, Perl, PHP, Python, Ruby.
• LIEF – LIEF provides a cross-platform library to parse, modify and abstract ELF, PE and MachO formats.
• ltrace – Dynamic analysis for Linux executables.
• mac-a-mal – An automated framework for mac malware hunting.
• objdump – Part of GNU binutils, for static analysis of Linux binaries.
• OllyDbg – An assembly-level debugger for Windows executables.
• OllyDumpEx – Dump memory from (unpacked) malware Windows process and store raw or rebuild PE file. This is a plugin for OllyDbg, Immunity Debugger, IDA Pro, WinDbg, and x64dbg.
• PANDA – Platform for Architecture-Neutral Dynamic Analysis.
• PEDA – Python Exploit Development Assistance for GDB, an enhanced display with added commands.
• pestudio – Perform static analysis of Windows executables.
• Pharos – The Pharos binary analysis framework can be used to perform automated static analysis of binaries.
• plasma – Interactive disassembler for x86/ARM/MIPS.
• PPEE (puppy) – A Professional PE file Explorer for reversers, malware researchers and those who want to statically inspect PE files in more detail.
• Process Explorer – Advanced task manager for Windows.
• Process Hacker – Tool that monitors system resources.
• Process Monitor – Advanced monitoring tool for Windows programs.
• PSTools – Windows command-line tools that help manage and investigate live systems.
• Pyew – Python tool for malware analysis.
• PyREBox – Python scriptable reverse engineering sandbox by the Talos team at Cisco.
• QKD – QEMU with embedded WinDbg server for stealth debugging.
• Radare2 – Reverse engineering framework, with debugger support.
• RegShot – Registry compare utility that compares snapshots.
• RetDec – Retargetable machine-code decompiler with an online decompilation service and API that you can use in your tools.
• ROPMEMU – A framework to analyze, dissect and decompile complex code-reuse attacks.
• Scylla Imports Reconstructor – Find and fix the IAT of an unpacked / dumped PE32 malware.
• ScyllaHide – An Anti-Anti-Debug library and plugin for OllyDbg, x64dbg, IDA Pro, and TitanEngine.
• SMRT – Sublime Malware Research Tool, a plugin for Sublime 3 to aid with malware analyis.
• strace – Dynamic analysis for Linux executables.
• StringSifter – A machine learning tool that automatically ranks strings based on their relevance for malware analysis.
• Triton – A dynamic binary analysis (DBA) framework.
• Udis86 – Disassembler library and tool for x86 and x86_64.
• Vivisect – Python tool for malware analysis.
• WinDbg – multipurpose debugger for the Microsoft Windows computer operating system, used to debug user mode applications, device drivers, and the kernel-mode memory dumps.
• X64dbg – An open-source x64/x32 debugger for windows.

Analyze network interactions.

• Bro – Protocol analyzer that operates at incredible scale; both file and network protocols.
• BroYara – Use Yara rules from Bro.
• CapTipper – Malicious HTTP traffic explorer.
• chopshop – Protocol analysis and decoding framework.
• CloudShark – Web-based tool for packet analysis and malware traffic detection.
• FakeNet-NG – Next generation dynamic network analysis tool.
• Fiddler – Intercepting web proxy designed for “web debugging.”
• Hale – Botnet C&C monitor.
• Haka – An open source security oriented language for describing protocols and applying security policies on (live) captured traffic.
• HTTPReplay – Library for parsing and reading out PCAP files, including TLS streams using TLS Master Secrets (used in Cuckoo Sandbox).
• INetSim – Network service emulation, useful when building a malware lab.
• Laika BOSS – Laika BOSS is a file-centric malware analysis and intrusion detection system.
• Malcolm – Malcolm is a powerful, easily deployable network traffic analysis tool suite for full packet capture artifacts (PCAP files) and Zeek logs.
• Malcom – Malware Communications Analyzer.
• Maltrail – A malicious traffic detection system, utilizing publicly available (black)lists containing malicious and/or generally suspicious trails and featuring an reporting and analysis interface.
• mitmproxy – Intercept network traffic on the fly.
• Moloch – IPv4 traffic capturing, indexing and database system.
• NetworkMiner – Network forensic analysis tool, with a free version.
• ngrep – Search through network traffic like grep.
• PcapViz – Network topology and traffic visualizer.
• Python ICAP Yara – An ICAP Server with yara scanner for URL or content.
• Squidmagic – squidmagic is a tool designed to analyze a web-based network traffic to detect central command and control (C&C) servers and malicious sites, using Squid proxy server and Spamhaus.
• Tcpdump – Collect network traffic.
• tcpick – Trach and reassemble TCP streams from network traffic.
• tcpxtract – Extract files from network traffic.
• Wireshark – The network traffic analysis tool.

Tools for dissecting malware in memory images or running systems.

• BlackLight – Windows/MacOS forensics client supporting hiberfil, pagefile, raw memory analysis.
• DAMM – Differential Analysis of Malware in Memory, built on Volatility.
• evolve – Web interface for the Volatility Memory Forensics Framework.
• FindAES – Find AES encryption keys in memory.
• inVtero.net – High speed memory analysis framework developed in .NET supports all Windows x64, includes code integrity and write support.
• Muninn – A script to automate portions of analysis using Volatility, and create a readable report.
• Rekall – Memory analysis framework, forked from Volatility in 2013.
• TotalRecall – Script based on Volatility for automating various malware analysis tasks.
• VolDiff – Run Volatility on memory images before and after malware execution, and report changes.
• Volatility – Advanced memory forensics framework.
• VolUtility – Web Interface for Volatility Memory Analysis framework.
• WDBGARK – WinDBG Anti-RootKit Extension.
• WinDbg – Live memory inspection and kernel debugging for Windows systems.

• AChoir – A live incident response script for gathering Windows artifacts.
• python-evt – Python library for parsing Windows Event Logs.
• python-registry – Python library for parsing registry files.
• RegRipper (GitHub) – Plugin-based registry analysis tool.

• Aleph – Open Source Malware Analysis Pipeline System.
• CRITs – Collaborative Research Into Threats, a malware and threat repository.
• FAME – A malware analysis framework featuring a pipeline that can be extended with custom modules, which can be chained and interact with each other to perform end-to-end analysis.
• Malwarehouse – Store, tag, and search malware.
• Polichombr – A malware analysis platform designed to help analysts to reverse malwares collaboratively.
• stoQ – Distributed content analysis framework with extensive plugin support, from input to output, and everything in between.
• Viper – A binary management and analysis framework for analysts and researchers.

• al-khaser – A PoC malware with good intentions that aimes to stress anti-malware systems.
• CryptoKnight – Automated cryptographic algorithm reverse engineering and classification framework.
• DC3-MWCP – The Defense Cyber Crime Center’s Malware Configuration Parser framework.
• FLARE VM – A fully customizable, Windows-based, security distribution for malware analysis.
• MalSploitBase – A database containing exploits used by malware.
• Malware Museum – Collection of malware programs that were distributed in the 1980s and 1990s.
• Malware Organiser – A simple tool to organise large malicious/benign files into a organised Structure.
• Pafish – Paranoid Fish, a demonstration tool that employs several techniques to detect sandboxes and analysis environments in the same way as malware families do.
• REMnux – Linux distribution and docker images for malware reverse engineering and analysis.
• Tsurugi Linux – Linux distribution designed to support your DFIR investigations, malware analysis and OSINT (Open Source INTelligence) activities.
• Santoku Linux – Linux distribution for mobile forensics, malware analysis, and security.

Essential malware analysis reading material.

• Learning Malware Analysis – Learning Malware Analysis: Explore the concepts, tools, and techniques to analuze and investigate Windows malware
• Malware Analyst’s Cookbook and DVD – Tools and Techniques for Fighting Malicious Code.
• Mastering Malware Analysis – Mastering Malware Analysis: The complete malware analyst’s guide to combating malicious software, APT, cybercime, and IoT attacks
• Mastering Reverse Engineering – Mastering Reverse Engineering: Re-engineer your ethical hacking skills
• Practical Malware Analysis – The Hands-On Guide to Dissecting Malicious Software.
• Practical Reverse Engineering – Intermediate Reverse Engineering.
• Real Digital Forensics – Computer Security and Incident Response.
• Rootkits and Bootkits – Rootkits and Bootkits: Reversing Modern Malware and Next Generation Threats
• The Art of Memory Forensics – Detecting Malware and Threats in Windows, Linux, and Mac Memory.
• The IDA Pro Book – The Unofficial Guide to the World’s Most Popular Disassembler.
• The Rootkit Arsenal – The Rootkit Arsenal: Escape and Evasion in the Dark Corners of the System

• APT Notes – A collection of papers and notes related to Advanced Persistent Threats.
• Ember – Endgame Malware BEnchmark for Research, a repository that makes it easy to (re)create a machine learning model that can be used to predict a score for a PE file based on static analysis.
• File Formats posters – Nice visualization of commonly used file format (including PE & ELF).
• Honeynet Project – Honeypot tools, papers, and other resources.
• Kernel Mode – An active community devoted to malware analysis and kernel development.
• Malicious Software – Malware blog and resources by Lenny Zeltser.
• Malware Analysis Search – Custom Google search engine from Corey Harrell.
• Malware Analysis Tutorials – The Malware Analysis Tutorials by Dr. Xiang Fu, a great resource for learning practical malware analysis.
• Malware Analysis, Threat Intelligence and Reverse Engineering – Presentation introducing the concepts of malware analysis, threat intelligence and reverse engineering. Experience or prior knowledge is not required. Labs link in description.
• Malware Persistence – Collection of various information focused on malware persistence: detection (techniques), response, pitfalls and the log collection (tools).
• Malware Samples and Traffic – This blog focuses on network traffic related to malware infections.
• Malware Search+++ Firefox extension allows you to easily search some of the most popular malware databases
• Practical Malware Analysis Starter Kit – This package contains most of the software referenced in the Practical Malware Analysis book.
• RPISEC Malware Analysis – These are the course materials used in the Malware Analysis course at at Rensselaer Polytechnic Institute during Fall 2015.
• WindowsIR: Malware – Harlan Carvey’s page on Malware.
• Windows Registry specification – Windows registry file format specification.
• /r/csirt_tools – Subreddit for CSIRT tools and resources, with a malware analysis flair.
• /r/Malware – The malware subreddit.
• /r/ReverseEngineering – Reverse engineering subreddit, not limited to just malware.

• Android Security
• AppSec
• CTFs
• Forensics
• Digital Forensics
• “Hacking”
• Honeypots
• Industrial Control System Security
• Incident-Response
• Infosec
• PCAP Tools
• Pentesting
• Security
• Threat Intelligence
• YARA

Pull requests and issues with suggestions are welcome! Please read the CONTRIBUTING guidelines before submitting a PR.

MIT License & cc license

This work is licensed under a Creative Commons Attribution 4.0 International License.

A Python script that grabs your Discogs records collection, the metadata of every release, and turns it into a CSV file that you can sort in a spreadsheets app, or process further if you modify the script.

Discogs themselves offer a feature to export CSV but it doesn’t let you export specific fields from a release. In my case I mostly wanted to export the genres and styles of every disc I have, in order to sort records by genre more easily. With some tweaking you can make this export whatever metadata about the record you want, and you could sort directly from Python if needed (I just found Excel much faster for tweaking sorting options until I got it right).

1. Get a personal access token in your Discogs preference, and copy it inside the vinylsget.py file.

2. pip install discogs_client

3. python3 vinylsget.py

4. open collection.csv in your favourite spreadsheet editor.

It’s very basic, but it’s a good starting point for similar projects, or if you are were bit unclear about how to use the Discogs Python library (I certainly was). One thing it doesn’t do very well is handle metadata that’s not excellently standardised; it shouldn’t spit out errors but it might sometimes give something like Album instead of CD, 12″ instead of 2xLP, the artist twice, compilations with a wrong artist name and so on.

Some of these things can probably be fixed, some of them are just down to bad tagging on Discogs and there’s not much I can do about that.

An Angular starter kit featuring Angular 20.0.0, Angular CLI 20.0.0

it’s part of a repo series designed to create a Progressive Web App with Angular

# choose a repo
# download the example or clone the repo from github
git clone https://github.com/ganatan/angular-ssr.git

# download the example or clone the repo from gitlab
git clone https://gitlab.com/ganatan/angular-ssr.git

# change directory
cd angular-ssr
cd frontend-angular

# install the repo with npm
npm install

# start the server
npm start

in your browser go to http://localhost:4200

• npm install (installing dependencies)
• npm outdated (verifying dependencies)

• npm run start
• in your browser http://localhost:4200

• npm run lint

• npm run test
• npm run coverage

• npm run build ( with SSR)

• npm run serve
• in your browser http://localhost:4000

• npm run test

• change directory cd ui
• launch html pages in your browser

• build image

• docker build -t angular-starter:1.0.0 .

• run container

• docker run -d -p 4000:4000 angular-starter:1.0.0

• run container mode bash

• docker run -it angular-starter:1.0.0 /bin/bash

• in your browser http://localhost:4000

• Author : danny

English Tutorials

• Tutorials Step-by-Step – https://www.ganatan.com/tutorials/en

Tutoriels en français

• Installation – https://www.ganatan.com/tutorials/modules-avec-angular
• Tutoriels Etape par étape – https://www.ganatan.com/tutorials

a simple session manager plugin

Neovim (and Vim) support saving and loading of sessions (windows, tabs, buffers,
etc), but the interface isn’t the easiest to use.

• :mksession <file> is required to save a session, and sessions are loaded with nvim -S <file> or :source <file>. If the file already exists, a bang is required
  mksession! <file>. This is a bit tedious and annoying when you do it wrong
  the first time.
• If the directories in the session filepath do not exist, :mksession will
  fail.
• It is easy to forget saving a session.

sessions.nvim is a lightweight wrapper around :mksession that adds a small
amount of pixie dust to make sessions management more simple and enjoyable.

• The commands :SessionsSave and :SessionsLoad are used to save and load
  session files.
• Further changes to the session are automatically saved to the session file
  after saving or loading a session.
• Session files created with sessions.nvim are independent of the plugin;
  loading with nvim -S or :source will not start autosaving.
• Intermediate directories are automatically created.
• A default session filepath may be customized.

sessions.nvim does not do anything automatically. Sessions will not be saved or
loaded until a command or an API function is called. This is to keep the plugin
simple and focused. The entire goal of sessions.nvim is to provide a wrapper
around :mksession and :source, not to provide workspace management.

Other plugins exist to automatically save and load sessions for each
project directory if that is what you desire. It also wouldn’t be difficult to
write an autocommand to load session files on nvim startup.

This readme covers most of the features of sessions.nvim, but full
documentation is found in the help file :h sessions.

Note that this plugin is small in scope and complexity. It has been stable for a
long time. Just because I am not making changes doesn’t mean it’s been
abandoned! It was designed to be small and stable, and it will stay that way.

sessions.nvim requires nvim 0.7.0 as a minimum. If you have an older version of
nvim, you may use the commit tagged
0.2.
(4b400a37).

Work on a project until ready to take a break. Run :SessionsSave .session to
save the current state to a hidden file .session. nvim may be closed.

Later return to the same path and open nvim. Run :SessionsLoad .session to
load the saved session. Now any changes to the window layout, buffers, tabs,
etc. will be saved when closing nvim.

See
natecraddock/workspaces.nvim
for an easy method of automatically restoring a session in saved workspace
folders.

Install with your favorite Neovim package manager. Be sure to call the setup
function if you wish to change the default configuration or register the user
commands.

require("sessions").setup()

The setup function accepts a table to modify the default configuration:

{
    -- autocmd events which trigger a session save
    --
    -- the default is to only save session files before exiting nvim.
    -- you may wish to also save more frequently by adding "BufEnter" or any
    -- other autocmd event
    events = { "VimLeavePre" },

    -- default session filepath
    --
    -- if a path is provided here, then the path argument for commands and API
    -- functions will use session_filepath as a default if no path is provided.
    session_filepath = "",

    -- treat the default session filepath as an absolute path
    -- if true, all session files will be stored in a single directory
    absolute = false,
}

For example, the following settings will save the session every time a window is
entered, and .nvim/session will be used as the default session filepath:

require("sessions").setup({
    events = { "WinEnter" },
    session_filepath = ".nvim/session",
})

When absolute is true, the session_filepath will store all session files.
In the following example, all session files will be stored in the nvim data/sessions
directory (~/.local/share/nvim/sessions on a Unix-like system)

require("sessions").setup({
    events = { "WinEnter" },
    session_filepath = vim.fn.stdpath("data") .. "/sessions",
    absolute = true,
})

This version is compatible with Neovim 0.6 and newer.

The setup function registers the following commands:

• :SessionsSave[!] [path]

  Save a session file to the given path. If the path exists it will be
  overwritten. Starts autosaving the session on the configured events.

• :SessionsLoad[!] [path]

  Load a session file from the given path. If the path does not exist no session
  will be loaded. Starts autosaving changes to the session after loading.

• :SessionsStop[!]

  Stops session autosaving if enabled. The current state will be saved before
  stopping.

See :h sessions-usage for more information on the commands.

The session commands may also be accessed from Lua:

local sessions = require("sessions")

sessions.save(path: string, opts: table)

sessions.load(path: string, opts: table)

sessions.start_autosave()

sessions.stop_autosave(opts: table)

sessions.recording(): bool

See :h sessions-api for more information on the Lua API.

In this demo video I create a sessions file at .nvim/session relative to my current
directory. I then repeatedly quit nvim, reopen and load the session, modify the layout,
and close nvim. Halfway through I no longer provide a path to :SessionsLoad because I
have configured my session_filepath to be “.nvim/session”.

If you want a more automatic solution, or something else, these plugins may interest you:

• tpope/vim-obsession Very similar,
  but modifies the session files to always autosave after sourcing.
• folke/persistence.nvim
  Automatically stores sessions in a shared directory on nvim exit.
• rmagatii/auto-session
  Automatically stores sessions in a shared directory.
• Shatur/neovim-session-manager
  Saves sessions and manages workspaces.

Для начала склонируйте репозиторий на свой компьютер. После клонирования откройте терминал и перейдите в директорию с репозиторием.

Далее вам нужно выбрать один из трех вариантов установки и выполнить соответствующую команду. После установки запустите команду, которая сгенерирует вам токен. Скопируйте полученный токен.

Затем перейдите в браузере по адресу http://localhost:8789. На этой странице вы сможете создать свой собственный пароль, используя скопированный токен. После этого ресурс с JupiterLab будет доступен вам по адресу http://localhost:8789, и вы сможете использовать его с созданным паролем.

1. Тежелый образ, в котором имеется сразу TensorFlow и PyTorch с доступом к GPU:

docker compose -f docker-compose-gpu-torch-tf.yml -p jupiter_lab_cv up -d --build

2. Более легкий образ, в котором имеется сразу PyTorch с доступом к GPU:

docker compose -f docker-compose-gpu-torch.yml -p jupiter_lab_cv up -d --build

3. Самый легкий образ без доступа к GPU (CPU лишь имеется):

docker compose -f docker-compose-cpu.yml -p jupiter_lab_cv up -d --build

docker exec jupiterlab jupyter server list

Помимо туториала по установке и запуску JupiterLab в репозитории содержится инструкция по настройке Linux сервера, которая поможет вам установить следующие компоненты: NVIDIA драйверы, CUDA Toolkit, Docker, NVIDIA Container Toolkit и Git.

Инструкция находится в файле server_setup.md. Следуя этой инструкции, вы сможете легко настроить ваш сервер для работы с GPU и другими необходимыми инструментами.